Practica 2 Algoritmo Genético Cobertura de Vertices Java

Introducción.

*En esta practica realizamos dos codificaciones en diferentes lenguajes, para comprender mejor y también para abarcar el lenguaje Python al igual que Java. Ambas codificaciones contienen sus respectivos puntos a tratar, introducción, código, vídeo etc.

El problema a analizar será vertex cover (cobertura de vértices) que es un problema NP-completo.

Este problema es muy utilizado en teoría de complejidad computacional para probar la pertenencia a la clase NP-Hard de otros problemas computacionales difíciles.

Por ejemplo:

• Clique
• Set covering
• Circuitos Hamiltonianos

El problema de la cobertura de vértices consiste en determinar una cobertura con el mínimo número de vértices.

El problema de poner guardias en los extremos (vértices) de los pasillos (lados) para cubrirlos todos por ejemplo es un problema de cubierta de vértices; el problema abastecer una colonia con el menor número de luminarias también lo es.

Cada vértice cubre su arco incidente y se trata de buscar el conjunto de vértices que cubra todos los arcos. La idea es encontrar la cobertura de vértices de tamaño mínimo.

En el siguiente grafo, {1,3,5,6} es una cobertura de vértices de tamaño 4. Sin embargo, esta no es la cobertura mínima, porque existen las coberturas de vértices {245} {124} y,ambas de tamaño 3 que satisfacen la cobertura.

 Objetivo.-  Minimizar la cantidad de nodos necesarios para la cubierta de un grafo dado, mediante un algoritmo genético.


 Justificación.- Por que es un problema de la vida cotidiana que no se puede esperar a tener una respuesta exacta del  problema supongamos que tienen que poner luminarias ahorrando la cantidad de estas en una colonia donde las calles son irregulares y el suministro de luz de las luminarias tiene que llegar a cada calle(aristas) y estas luminarias se tienen que poner en intersecciones con diferentes calles (nodos) así se tiene un ejemplo de como utilizar el algoritmo.

 Desarrollo.- Se necesitaran los siguientes datos recibidos como parametros para poder correr el programa: numero de nodos/vértices  y densidad del grafo (cantidad de enlaces entre nodos) y poblacion probabilidad de cruzamiento/mutación

ejemplo : karenalduncin@lilalduncin:~/Dropbox/LAB Adaptativos$ java Arista.java 12 .5 10 .4

Código.- Aqui se muestran las partes mas importantes del código:

/**Metaheurísticade genetica Basica 
       Incluye metodos 
       -poblacion
       -cromosoma
       -cubierta
       -mutacion 
       -nacimiento 
       -ruleta para la seleccion aleatoria :| <- :P
     */
    //genetica <3

    /**
       Metodo Poblacion
       recibe el grafo y el tamaño de la pobacion
       genera una poblacion a partir de soluciones iniciales 
     */
    // genera una poblacion inicial
    public static ArrayList<ArrayList<Integer>> poblacion(ArrayList <Arista> grafo,int tam)//verif
    {
 ArrayList<ArrayList<Integer>> lista= new ArrayList<ArrayList<Integer>>();//lista de listas de enteros
 while(lista.size()<=tam)//mientras que la lista aun sea menor al tamaño
     {
  lista.add(Arista.inicial(grafo));//agrega una solucion inicial a la lista de poblacion
     }
 System.out.println("Poblacion @_@");//flag
 Arista.imprime(lista);//imprime dicha lista //flag
 return lista;//regresa la lista para utilizarla 
    }
    //cromosoma
    /**
       metodo cromosoma transforma la solucion inicial en binario 
       recibe una solucion inicial (conjunto de vertices que forman la cubierta)
       y la cantidad total de vertices 
       
     */
    public static ArrayList<String> cromosoma(ArrayList<Integer> seleccion, int cantidad) //cantidad total de vertices 
    {
 ArrayList<String> ref = new ArrayList<String>();//cadena de caracteres 0 y 1 para representarlo
 for(int i=0;i<cantidad;i++)//recorre el arreglo
     {
  if(seleccion.contains(i))//si contiene el numero referenciado al indice
     {
         ref.add("1");//agrega un uno
     }
     else
         ref.add("0");//si no ... un cero 
     }
 //Arista.imprime(ref);
        return ref;//regresa el patron de referencia en binario
    }

    /**metodo cubierta 
       recibe la referencia en binario de la solucion (conjunto de vertices que forman la cubierta)
       
     */
    public static ArrayList<Integer> cubierta (ArrayList<String> cromosoma)
    {
 ArrayList<Integer> selection= new ArrayList<Integer>(); 
 int pos =0;
  for (int i=0;i<cromosoma.size();i++)
     {
  if((cromosoma.get(i)).equals("1"))//si es igual a 1 
      selection.add(pos);//agrega la "iteracion" actual a el conjunto cubierta
  pos+=1;
     }
 //System.out.println("cubierta");//flag
 //Arista.imprime(selection);//flag
 return selection;//regresa el conjunto 
    }
 /**
       metodo mutacion
       recibe una poblacion de soluciones iniciales 
       el total de vertices y el grafo 
       elije un individuo a cambiar atravez del metodo ruleta que selecciona
    */
public static void mutacion(ArrayList<ArrayList<Integer>>poblacion,int verticestotales,ArrayList<Arista> g)
    {
 int individuo = ruleta(poblacion);
 ArrayList<Integer> id = poblacion.get(individuo);//selecciono el individuo que voy a mutar  
 ArrayList<String> cr =cromosoma(id,verticestotales);
 int ubic= Arista.r.nextInt(verticestotales);
 if (cr.get(ubic)== "0")//si el individuo seleccionado es igual a 0
     {
  cr.set(ubic,"1"); 
     }
 else
     {
  cr.set(ubic,"0");
     }
 ArrayList <Integer> mutante = Arista.cubierta(cr);
 //int objetivo = Arista.objetivo(mutante);
 boolean fact = Arista.factible(mutante,g);
 if(fact==true )
     poblacion.add(mutante);
 return;
    }
/**
       metodo generacion manda llamar a todos los metodos del algoritmo heuristico de genetica basica recibe la lista de aristas de coneccion (grafo)y el tamaño de la poblacion de las generaciones
     */
public static void generacion(ArrayList<Arista> grafo,int tam,double cruz,double mut)
    {
 ArrayList<ArrayList<Integer>> pob = poblacion(grafo,tam);
 int n=pob.size();
 for(int i=0;i<(int)Math.floor(tam * cruz);i++)
     {
  Arista.nacimiento(pob,n,grafo);
  for (int m=0;m<(int)Math.floor(tam * mut);m++)
      {
   Arista.mutacion(pob,n,grafo);
      }
     }
 Arista.matanza(pob);
 System.out.println("Despues de la  Matanza:");//futura mejora por que se repiten :/
 Arista.imprime(pob);
 return;
    }

Resultados.-

 Video en youtube.-


 Conclusiones.- Esta entrada es complemento de la entrada anterior donde se muestra también un algoritmo genético programado en python con gráficas y su explicación, también es una recopilación del trabajo anterior en la clase de Temas Selectos de Optimización donde se muestran mas algoritmos de programación heúristica de este problema y donde se muestra en el siguiente enlace la primera versión del AG de VC el cual se modifico para poder tener los resultados esperados.
Link de Referencia:  http://ts-optimizacion.blogspot.mx
Autor: Karen Alduncin et Al.
y añadimos un video para que se pueda entender mejor el problema de la cobertura de vértices.

Practica #2 - Algoritmos genéticos

Introducción

El tema seleccionado de Cómputo evolutivo, fue el de algoritmos genéticos.

Los Algoritmos Genéticos (AGs) son métodos adaptativos que pueden usarse para resolver problemas de búsqueda y optimización.

Los algoritmos genéticos son métodos sistemáticos para la resolución de problemas de búsqueda y optimización que aplican a estos los mismos métodos de la evolución biológica: selección basada en la población, reproducción sexual y mutación.

Los algoritmos genéticos son métodos de optimización, que tratan de resolver el mismo conjunto de problemas que se ha contemplado anteriormente, es decir, hallar (xi,...,xn) tales que F(xi,...,xn) sea máximo. En un algoritmo genético, tras parametrizar el problema en una serie de variables, (xi,...,xn) se codifican en un cromosoma. Todas los operadores utilizados por un algoritmo genético se aplicarán sobre estos cromosomas, o sobre poblaciones de ellos. En el algoritmo genético va implícito el método para resolver el problema; son solo parámetros de tal método los que están codificados, a diferencia de otros algoritmos evolutivos como la programación genética. Hay que tener en cuenta que un algoritmo genético es independiente del problema, lo cual lo hace un algoritmo robusto, por ser útil para cualquier problema, pero a la vez débil, pues no está especializado en ninguno.

Las soluciones codificadas en un cromosoma compiten para ver cuál constituye la mejor solución (aunque no necesariamente la mejor de todas las soluciones posibles). El ambiente, constituido por las otras camaradas soluciones, ejercerá una presión selectiva sobre la población, de forma que sólo los mejor adaptados (aquellos que resuelvan mejor el problema) sobrevivan o leguen su material genético a las siguientes generaciones, igual que en la evolución de las especies. La diversidad genética se introduce mediante mutaciones y reproducción sexual.

En la Naturaleza lo único que hay que optimizar es la supervivencia, y eso significa a su vez maximizar diversos factores y minimizar otros. Un algoritmo genético, sin embargo, se usará habitualmente para optimizar sólo una función, no diversas funciones relacionadas entre sí simultáneamente. La optimización que busca diferentes objetivos simultáneamente, denominada multimodal o multiobjetivo, también se suele abordar con un algoritmo genético especializado.

Por lo tanto, un algoritmo genético consiste en lo siguiente: hallar de qué parámetros depende el problema, codificarlos en un cromosoma, y se aplican los métodos de la evolución: selección y reproducción sexual con intercambio de información y alteraciones que generan diversidad. En las siguientes secciones se verán cada uno de los aspectos de un algoritmo genético.

Objetivo ¿Qué piensas lograr?

La solución de un problema de maximización de Optimización…

Un escritor tiene que redactar un número de obras de la literatura en un tiempo conocido. Cada libro tiene un tiempo de redacción y un beneficio asociado. Se desea saber cuál es el máximo benecito alcanzable.

Una vez evaluado el fitness, se tiene que crear la nueva población teniendo en cuenta que los buenos rasgos de los mejores se transmitan a esta. Para ello, hay que seleccionar a una serie de individuos encargados de tan ardua tarea. Y esta selección, y la consiguiente reproducción.

Rueda de ruleta: se crea un pool genético formado por cromosomas de la generación actual, en una cantidad proporcional a su fitness. Si la proporción hace que un individuo domine la población, se le aplica alguna operación de escalado. Dentro de este pool, se cogen parejas aleatorias de cromosomas y se emparejan, sin importar incluso que sean del mismo progenitor (para eso están otros operadores, como la mutación).

Los Algoritmos Genéticos (AGs) son métodos adaptativos que pueden usarse para resolver problemas de búsqueda y optimización.

Justificación ¿Por qué ese tema?

Porque la técnica de los algoritmos genéticos, resuelven problemas, de una forma muy eficaz, Algoritmos Genéticos son capaces de ir creando soluciones para problemas del mundo real y este tema ya fue abordado en clase.

Desarrollo

Se programo un Algoritmo Genético resolviendo el problema mencionado anteriormente, generando las poblaciones sucesivas a las que se aplican los operadores de mutación y cruce.

Cada individuo representa una solución al problema, y se trata de encontrar al individuo que represente a la mejor solución.

Instancia Aleatoria para Establecer el Valor de cada obra (1000,2000, o 3000 pesos) y tiempo Empleado en redacción( 20 a 100 horas) correspondiente a cada Libro.

Parámetros importantes en el ag. Llamado Libros: cantidad de libros, valor de los libros (miles de pesos), tiempo total en redacción de las obras, tiempo del que se dispone para efectuarlas, el tamaño de la generación, la lista de la generación, probabilidad de mutación de los cromosomas, la aptitud total, mejor individuo , aptitud, tiempo, la nueva generación, y la lista con los mejores individuos y aptitudes del ag.

Código

import random
import math

class Libros:
    
    def __init__(self, cl, v, t, td, pm, tm, Lmi, Lma):
        
        self.cant_libros=cl
        self.valor_libros=v
        self.tiempos=t
        self.tiempo_disponible=td
        self.tam_generacion=tm
        self.generacion=[] 
        self.prob_mutacion=pm 
        self.aptitud_total=0.0
        self.aptitudes={} 
        self.mejor_individuo='' 
        self.mejor_aptitud=-1
        self.ruleta=[]
        self.mejor_tiempo=100
        self.nueva_generacion=[] 
        self.Lista_mejores_individuos=Lmi
        self.Lista_mejores_aptitudes=Lma
    def poblacion_inicial(self):
        poblacion=random.sample(xrange(0,pow(2,self.cant_libros)-1),self.tam_generacion) #Obtiene una muestra de numeros aleatorios en un cierto rango
        print '......Poblacion inicial......: '
        print '__________________________________________________________________'
        for individuo in poblacion:
            cromosoma=bin(individuo)[2:] #Para quitar el 0b del string
            cromosoma=cromosoma.zfill(self.cant_libros) #Rellena con ceros el string para que quede de un cierto largo (asi todos quedan iguales)
            self.generacion.append(cromosoma)
            print individuo,' ',cromosoma
        
            
    def evaluacion_poblacion(self):
        print '......Evaluacion de poblacion......'
        print '__________________________________________________________________'
        self.aptitud_total=0
        self.aptitudes={}
        
        for cromosoma in self.generacion:
            aptitud=0.0
            tiempo=0.0
            for i in range(0,self.cant_libros):
              
                aptitud+=int(cromosoma[i])*self.valor_libros[i] 
                tiempo+=int(cromosoma[i])*self.tiempos[i]
            if tiempo > self.tiempo_disponible:
                aptitud=0.0
            self.aptitudes[cromosoma]=aptitud
            self.aptitud_total+=aptitud
            if aptitud > self.mejor_aptitud:
                self.mejor_individuo=cromosoma
                self.mejor_aptitud=aptitud
                self.mejor_tiempo=tiempo
                Lista_mejores_aptitudes.append(aptitud)
                Lista_mejores_individuos.append(cromosoma)
            
                
             
            print cromosoma,' ',aptitud,' ',tiempo
            
            
            print "Aptitud total: " + str(self.aptitud_total)
        
    def seleccion(self):
        print 'Seleccion de individuos'
        self.ruleta=[]
        for cromosoma in self.aptitudes:
            cacho=int(math.ceil(self.aptitudes[cromosoma]/self.aptitud_total*100))
            print 'Al cromosoma ',cromosoma,' le corresponden ',cacho,' espacios.'
            for i in range(0,cacho):
                self.ruleta.append(cromosoma)
        random.shuffle(self.ruleta) 
    
    def cruce(self):
        
        print 'Cruza de individuos'
        print '__________________________________________________________________'
        punto_cruce=random.randint(1,self.cant_libros-2)
        bebes=[]
        print 'El punto de cruce escogido es ',punto_cruce
        for  i in range(len(self.generacion)):
            papa=random.choice(self.ruleta) #Este metodo obtiene de manera aleatoria un elemento de una lista.
            mama=random.choice(self.ruleta)
            hijo1=papa[:punto_cruce] + mama[punto_cruce:] 
            hijo2=mama[:punto_cruce] + papa[punto_cruce:]
            bebes.append(hijo1) #Se guardan los hijos 
            bebes.append(hijo2)
            #print len(bebes)
            print 'Papas',papa,' ',mama,' generan hijos ',hijo1,' y ',hijo2
        self.nueva_generacion=random.sample(bebes,len(self.generacion))
        print 
        print 'Nueva generacion: '
        for individuo in self.nueva_generacion:
            print individuo
          
  
    def mutar(self):
        print 'Mutacion'
        print '__________________________________________________________________'
        poblacion=[]
        for cromosoma in self.nueva_generacion:
            crom_mutado=''
            for gen in cromosoma:
                r=random.random()
                if(r<=self.prob_mutacion):
                    crom_mutado+=str(abs(int(gen)-1))
                    print 'Mutando el gen del cromosoma',cromosoma
                else:
                    crom_mutado+=gen
            poblacion.append(crom_mutado)
        self.nueva_generacion=poblacion #Se restablecen los cromosomas
        print
        print 'Nueva generacion mutada (X-boys): '
        for individuo in self.nueva_generacion:
            print individuo
            

    #Se cambia la generacion anterior
    def hacer_cambio_generacional(self):
        self.generacion=self.nueva_generacion

    #Metodo get para el mejor individuo
    def get_mejor_individuo(self):
        return self.mejor_individuo
     
    #Metodo get para la mejor aptitud
    def get_mejor_aptitud(self):
        return self.mejor_aptitud

    #Metodo get para la mejor aptitud
    def get_mejor_tiempo(self):
        return self.mejor_tiempo
    #metodo get para obtener lista con mejores individuos

def get_mejores_individuos(self):
    return self.Lista_mejores_individuos
    #metdo get paraobtener la lista con mejores aptitudes
def get_mejores_aptitudes(self):
    return self.Lista_mejores_aptitudes

valor_libros=[]

for i in range(0,10):
    
    valor_libros.append(random.randint(1, 3))
print" Valor correspondiente de cada libro(miles pesos):", valor_libros

tiempos=[]
Lista_mejores_individuos=[]
Lista_mejores_aptitudes=[]
for i in range(0,10):
    
    tiempos.append(random.randint(20, 100))
print "Tiempo que se emplea en escribir cada libro(horas): ", tiempos


cantidad_objetos=len(valor_libros)

# se pide el tiempo limite para escribir las obras
# se crea el objeto algoritmo genetico
td = int(raw_input(" Ingrese las horas disponibles para escribir las obras: "))
while td < 40:
    print "No se puede escribir ninguna obra \n"
    td = int(raw_input(" Ingrese las horas disponibles para escribir las obras: "))


ag=Libros(cantidad_objetos, valor_libros, tiempos, td, 0.1, 20, Lista_mejores_individuos, Lista_mejores_aptitudes)
print

#Se crea una poblacion incial
ag.poblacion_inicial()
print


iteraciones=10
#Proceso de el algoritmo genetico
for i in range(0,iteraciones):
    ag.evaluacion_poblacion()
    print 
    ag.seleccion()
    print
    ag.cruce()
    print
    ag.mutar()
    print
    ag.hacer_cambio_generacional()

ag.evaluacion_poblacion()


print 
print 'Mejor combinacion de libros : ',ag.get_mejor_individuo()
print 'Mejor aptitud (ganancia miles ): ',ag.get_mejor_aptitud()
print "El tiempo que se escribiran las obras:", ag.get_mejor_tiempo()

print "Lista de mejores individuos", Lista_mejores_individuos
print "Lista de mejres aptitudes", Lista_mejores_aptitudes
print "\n\n\n"
print "La grafica de aptitudes es:"
c=0
for elementos in Lista_mejores_individuos:
    c=c+1
g=0.0
x=0
Lista_grafica=[]
for i in range(0,c):
    print "\n"
    g=Lista_mejores_aptitudes[i]
    while (x<g):
        Lista_grafica.append("*")
        x=x+1
    print Lista_mejores_individuos[i], Lista_grafica

Resultados

Primeramente se muestra El precio correspondiente a cada obra , junto con el tiempo en horas que se empleara para la transcripción.

Se ingresa las horas disponibles que el escritor tendrá, en este caso 20.

Se genera la población inicial aleatorea

Se evalúa la población, podemos notar que si el tiempo se sobrepasa del establecido la aptitud se hace 0.0 (no es factible)

Selección de individuos correspondientes a su aptitud.(utilizando al ruleta), 

Cruza de individuos
Se seleccionan aleatoriamente dos individuos de la ruleta, de los cuales posteriormente nacerán las próximas generaciones. Con los genes antes del punto cruce de el primer individuo, y después del punto cruce del segundo individuo. Y viceversa.

Entonces se obtiene la nueva generación

Que después se mutara lanzando un numero aleatorio; si cae dentro del rango de la probabilidad de mutación, se cambia el gen por su contrario: es decir, si es 1 lo cambiamos por 0 y viceversa.

Se obtiene la nueva generación mutada y se evalúa nuevamente de acuerdo a su aptitud.

Se repite el proceso 10 veces(10 iteraciones) para obtener a el mejor individuo, obteniendo los resultados siguientes

Vídeo

Conclusiones

La realización de este algoritmo genético nos permitió conocer e implementar una técnica de búsqueda basada en la teoría de la evolución de Darwin, que ha cobrado tremenda popularidad en todo el mundo durante los últimos años. 

El tema es muy interesante, las mejoras futuras pueden una interfaz que muestre como van incrementando las aptitudes a lo largo de este proceso, 

Se aprendió que mediante esta técnica se pueden resolver una gran cantidad de problemas

Practica 1

Practica 1

Control de semáforos

La siguiente práctica involucra temas de la Unidad 1 de Programación de Sistemas Adaptativos.

Descripción de la práctica

Introducción

En esta práctica, se implementa  un sistema que simule calles congestionadas y regula automáticamente la duración de las luces verdes en los semáforos de los cruces.

Consta de una avenida importante Av. Lincoln y se intercepta con una calle Aguaturma donde salen y entran carros a una colonia ubicada en dicha av.

Se necesitarón 3 semáforos que controlan la fluidez del cruce.

Semáforo A y Semáforo B controlan el paso vehicular de la av.

Semáforo b. Accede el paso a los carros que entran a la Calle.

Y Finalmente el Semáforo C que  permite a los carros salir de la calle para integrarse a la av.

Desarrollo

Son más carros en espera del paso  en LINCOLN, que los que esperan salir y entrar a AGUATURMA.

Se necesitaba controlar la duración del semáforo para evitar el congestionamiento entre la Av. y la calle.

Definitivamente se le tenía que dar prioridad a la Av. Pero sin descuidar el paso de carros en espera de la calle y para entrar en esta.

Diseño del cruce

Los posibles caminos que podían tomar los carros son los siguientes.

Para evitar Colisiones entre autos.

Se toma en cuenta la matriz de conflictos

A	B	b	C	ESTADO DEL SEMAFORO
0	0	0	0	SEMAFOROS APAGADOS
0	0	0	1	SEMAFORO C
0	0	1	0	SEMAFORO b
0	0	1	1	COLISION
0	1	0	0	COLISION
0	1	0	1	COLISION
0	1	1	0	COLISION
0	1	1	1	COLISION
1	0	0	0	COLISION
1	0	0	1	COLISION
1	0	1	0	COLISION
1	0	1	1	COLISION
1	1	0	0	SEMAFORO A Y B
1	1	0	1	COLISION
1	1	1	0	COLISION
1	1	1	1	COLISION

Diseño de la solución:

Lenguaje de Programación utilizado  Java

Simulación de carros en espera.

¿Cuántos automóviles desean pasar?

Los carros son generados con la ayuda de la función random*, para adaptarlo a la realidad, el rango del numero de carros en espera en la av. Es mayor que el número de carros que desean entrar y salir de la calle.

Carros en espera  de la luz verde del semáforo A: 0-100 carros.

Carros en espera de la luz verde del semáforo B: 0-100 carros.

Carros en espera de la luz verde del semáforo b: 0-100 carros.

Carros en espera de la luz verde del semáforo C: 0 a 40 carros.

Basándose en que: en la Av. y la calle pasan 1 automóvil/s. Se establece el estado de los  semáforos

Simulación de la duración en las luces.

¿Cuánto tiempo dura la luz del semáforo?

La luz verde del semáforo se le asigna a  el número mayor de carros que están en espera para que todos obtengan su servicio.

Ejemplo:

Carros en espera en el semáforo A: 40

Carros en espera en el semáforo B: 35

Carros en espera en el semáforo b: 7

Carros en espera en el semáforo C: 6

La Luz verde del semáforo se encenderá automáticamente en el semáforo  A en la misma razón de 1/s , en decir, 40 segundos, para que pasen los 40 carros.

Código

Código Completo:

EnsendidoDeSemaforos.java          Semaforo.java    

semaforos.java         trafico.java

Elementos de Código más Relevantes:

trafico.java :

package SemaforoGUI;
import java.awt.Graphics;
import javax.swing.JFrame;
import javax.swing.JLabel;
public class trafico  extends Thread 
{
    public static final int Trafico = 0;
    public int semaforoB, semaforob, semaforoC, opcion=0;
    public int semaforoA;
    public int random ()
    {
 double valor;
 Double resultado;
 int limSup=10;
 int limInf = 0;
 valor = Math.floor(Math.random()*(limSup-limInf+1)) + limInf;
 resultado = new Double(valor);
 return resultado.intValue(); 
    }
    public trafico()
    {
 semaforoA=random();
 semaforoB=random();
 semaforoC=random();  
 semaforob=random();
 while(semaforoC>40){
     semaforoC=random();  
 }
    }
    public void run(){   
 int Trafico;
 try{
     while(true){
  semaforoA=random();
  semaforoB=random();
  semaforob=random();
  semaforoC=random();
  Trafico=0;
  while(semaforoC>40){
      semaforoC=random();  
  }
  System.out.println("el numero de carros semaforo A es:" +semaforoA); 
  System.out.println("el numero de carros semaforo B es:" +semaforoB);
  System.out.println("el numero de carros semaforo b es:" +semaforob);
  System.out.println("el numero de carros semaforo C es:" +semaforoC);
  if(Trafico<semaforoA){
      Trafico=semaforoA;   
  }
  else{
      Trafico=Trafico;
  }
  if(Trafico<semaforoB){
      Trafico=semaforoB;
  }
  else
      Trafico=Trafico;
  if(Trafico<semaforob){
      Trafico=semaforob;
  }
  else
      Trafico=Trafico;
  if(Trafico<semaforoC){
      Trafico=semaforoC;
  }
  new EnsendidoDeSemaforos(Trafico, semaforoA, semaforoB, semaforob, semaforoC, opcion);
  sleep(Trafico*1000);
     }
 }catch(InterruptedException e){
     System.out.println(":0!!! Excepcion! -- " + e.getMessage());
 }
    }
}

EnsendidoDeSemaforos.java :

package SemaforoGUI;
public class EnsendidoDeSemaforos extends trafico
{
    public EnsendidoDeSemaforos(int Trafico, int semaforoA, int semaforoB, int semaforob, int semaforoC, int opcion)
    {
 if(Trafico==semaforoA)
     {
  opcion=1;
  System.out.println("Donde hay mas carros es en el semaforo A con :" +Trafico+" carros \n");
     }
 if(Trafico==semaforoB)
     {
  opcion=2;
  System.out.println("Donde hay mas carros es en el semaforo B con :" +Trafico+" carros \n");   
     }
 if(Trafico==semaforob)
     {
  opcion=3;
  System.out.println("Donde hay mas carros es en el semaforo b con :" +Trafico+" carros \n");
     }
 if(Trafico==semaforoC)
     {
  opcion=4;
  System.out.println("Donde hay mas carros es en el semaforo C con :" +Trafico+" carros \n");
     }
 orden_semaforos(opcion, Trafico);
    }
    public void orden_semaforos(int opcion, int Trafico)
    {
 Semaforo Valor = new Semaforo();
 switch(opcion)
     { 
     case 1:
  System.out.println("El semaforo A en verde dura :" +Trafico+" segundos ");
  System.out.println("El semaforo B en verde dura :" +Trafico+" segundos ");
  System.out.println("El semaforo b apagado ");
  System.out.println("El semaforo C en rojo ");
  Valor.semaforoV.setVisible(true);
  Valor.semaforoR.setVisible(false);
  Valor.semaforo2V.setVisible(true);
  Valor.semaforo2.setVisible(false);
  Valor.semaforo2R.setVisible(false);
  Valor.semaforo3R.setVisible(true);
  Valor.semaforo3V.setVisible(false);
  Valor.CarroA.setVisible(true);
  ;
  break;
     case 2:
  System.out.println("El semaforo B en verde dura:" +Trafico+" segundos");
  System.out.println("El semaforo A en verde dura :" +Trafico+" segundos ");
  System.out.println("El semaforo b apagado ");
  System.out.println("El semaforo C en rojo");
  Valor.semaforoV.setVisible(true);
  Valor.semaforoR.setVisible(false);
  Valor.semaforo2V.setVisible(true);
  Valor.semaforo2.setVisible(false);
  Valor.semaforo2R.setVisible(false);
  Valor.semaforo3R.setVisible(true);
  Valor.semaforo3V.setVisible(false);
  ;
  break;
     case 3: 
  System.out.println("El semaforo b dura:" +Trafico+" segundos");
  System.out.println("El semaforo A en rojo");
  System.out.println("El semaforo B en rojo");
  System.out.println("El semaforo C en rojo");
  Valor.semaforoV.setVisible(false);
  Valor.semaforoR.setVisible(true);
  Valor.semaforo2V.setVisible(false);
  Valor.semaforo2.setVisible(true);
  Valor.semaforo2R.setVisible(false);
  Valor.semaforo3R.setVisible(true);
  Valor.semaforo3V.setVisible(false);
  ;
  break;
     case 4:
  System.out.println("El semaforo C dura:" +Trafico+" segundos");
  System.out.println("El semaforo A en rojo");
  System.out.println("El semaforo B en rojo");
  System.out.println("El semaforo b apagado");
  Valor.semaforoV.setVisible(false);
  Valor.semaforoR.setVisible(true);
  Valor.semaforo2V.setVisible(false);
  Valor.semaforo2.setVisible(false);
  Valor.semaforo2R.setVisible(true);
  Valor.semaforo3R.setVisible(false);
  Valor.semaforo3V.setVisible(true);
  ;
  break;
     default:;
     };
    }
}

Video en youtube

Conclusiones

Durante la elaboración de la práctica, se obtuvo un panorama más amplio referente a la programación de sistemas Adaptativos.

Desde el análisis de la simulación a realizar, el continuo monitoreo del programa, el ajuste de parámetros necesarios, y la ejecución con ayuda de Threads

Mejoras futuras: Hacer el programa mucho más apegado a la realidad con el monitoreo previamente del ambiente, las horas pico, el día, valor más aproximado de carros en espera dependiendo, de otros factores como el clima y establecerlo para la disminución de tráfico entre calles.

Referencias

Libro Java para estudiantes.

Autor Douglas Bell