EXTRA

Ventilador.
pide temperatura mínima y máxima y va aumentando gradualmente a como va avanzando el tiempo y si la temperatura es menor de 20 grados el clima se apaga o mayor se prende automáticamente.

K means

Del codigo resalta la parte en donde realiza los calculos.
Primero checa la distancia entre dos centroides y despues entre los menores de esa comparacion previa para ver el punto mas cercano.
Despues se le agrega el grupo y se recalculan los centroides.



for(int IT = 0; IT < ITERACIONES; IT++){
   System.out.println("");
   for(int i = 0; i < punto.length; i++){
aux1 = (distancia.euclidea( punto[i], centroide[0]) < distancia.euclidea(punto[i], centroide[1])) ? 0 : 1;
aux2 = (distancia.euclidea( punto[i], centroide[2]) < distancia.euclidea(punto[i], centroide[3])) ? 2 : 3;

punto[i].setGrupo((distancia.euclidea( punto[i], centroide[aux1]) < distancia.euclidea(punto[i], centroide[aux2])) ?
 (aux1+1):(aux2+1) );

System.out.println("Punto["+(i+1)+"] En grupo: "+punto[i].getGrupo());
   }
   for(int i = 0; i < centroide.length; i++){
centroide[i] = distancia.recCentroide(punto,centroide[i],(i+1));
   }
 
}

Entregable3

">

Entregable4

View more presentations from mandymota.


CODIGO

La matriz de los jugadores


private int nValores[][]={
        {-150,0,5},  // Jugador 1  
        {-80,-45,3},  // Jugador 2
        {-100,0,3},  // Jugador 3  
        {-80,45,3},  // Jugador 4  
        {-50,0,10},  // Jugador 5  
        {0,-55,3},  // Jugador 6  
        {0,55,3},  // Jugador 7  
        {80,-60,7},  // Jugador 8
        {80,60,7},  // Jugador 9
        {65,0,7},  // Jugador 10    
        {100,15,6} // Jugador 11  
    };

Parte defensiva


 if (bola.getX() < 10)
          {
            for (int n=5;n<9 && n!=nJug;n++)
            comandos.add(new ComandoIrA (n,(nValores[n][0])-60, nValores[n][1]));
         
        }
         
     if(bola.getX() < -60 && bola.getY() >-70 && bola.getY() <70)
     {
           
            int contrario1=sj.getContrarioMasCerca(1);
            int contrario2=sj.getContrarioMasCerca(3);
            if (contrario1!=contrario2 && sj.getMasCercanoDeBola()!=1 && sj.getMasCercanoDeBola()!=3){
                comandos.add(new ComandoIrA (1,contrarios[contrario1].getX()+10,contrarios[contrario1].getY()));
                comandos.add(new ComandoIrA (3,contrarios[contrario2].getX()+10,contrarios[contrario2].getY()));
            }
            if (contrario1==contrario2)
            {
                if (contrarios[contrario1].getY()>=0) {
                 comandos.add(new ComandoIrA (3,contrarios[contrario1].getX()+10,contrarios[contrario1].getY()));
                     }
                else    {    
                    comandos.add(new ComandoIrA (1,contrarios[contrario1].getX()+10,contrarios[contrario1].getY()));
                        }
         
             }
       }

Aquí hay varias clases que el sistema ya tiene por defecto como la de comandos.

ATAQUE



if(bola.getX() >= 10) {
           
            for (int n=1;n<5 && n!=nJug;n++){
                comandos.add(new ComandoIrA (n,(nValores[n][0])+40, nValores[n][1])) ;
            }
                   }
         
       if(bola.getX() >= 85)
       {
              comandos.add(new ComandoIrA (1,15,-70)) ;
              comandos.add(new ComandoIrA (2,0,0)) ;
              comandos.add(new ComandoIrA (3,15,70)) ;
              comandos.add(new ComandoIrA (4,45,0)) ;
              comandos.add(new ComandoIrA (5,55,-55)) ;
              comandos.add(new ComandoIrA (6,55,55));
           
              for (int j=7;j<11;j++){
                 if (nJug!=j) {
                     int contrario4=sj.getContrarioMasCerca(j);
                     if ((( contrarios[contrario4].getX() )-( misJugadores[j].getX() )<10) && ( ( contrarios[contrario4].getX() )-( misJugadores[j].getX() )>=0)){
                       comandos.add(new ComandoIrA (j, (contrarios[contrario4].getX())+5, misJugadores[j].getY() ));
                     }
                 }
             }
         
          int contrario3=sj.getContrarioMasCerca(4);
          comandos.add(new ComandoIrA (4,contrarios[contrario3].getX()+5, nValores[4][1])) ;
         
     
       }

Aquí el sj también ya esta en una clase del sistema, la cual significa situación del jugador. La de bola y comandoIrA también están en clase del sistema.

estas serian las partes mas importantes del proyecto en si.

 

Juegovida

View more PowerPoint from sick007

                                      Código: 

while(true) {

            for (int i=1 ; i<=10 ; i++) {

                  for (int j=1 ; j<=10 ; j++) {

                  despues[i][j] = nuevoEstado(i,j);

                  }

}

for (int i=1 ; i<=10 ; i++) {

linea="";

      for (int j=1 ; j<=10 ; j++) {

            if (antes[i][j] == 1)

                  linea += "X";

            else

                  linea += "O";

}

System.out.println(linea);

}

for (int i=1 ; i<=10 ; i++) {

      for (int j=1 ; j<=10 ; j++) {

            antes[i][j] = despues[i][j];

}

}

System.out.println("-------------------");

try {

Thread.sleep(500);

} catch (Exception ex) {}

}

}

}

private static int nuevoEstado(int i, int j) {

int vecinos;

vecinos = antes[i-1][j-1]+antes[i][j-1]+antes[i+1][j-1];

vecinos += antes[i-1][j]+antes[i+1][j];

vecinos += antes[i-1][j+1]+antes[i][j+1]+antes[i+1][j+1];

if ((vecinos == 3) && (antes[i][j] == 0))

      return 1;

else if (((vecinos == 2) || (vecinos == 3)) && (antes[i][j]==1))

      return 1;

else

      return 0;

}

                            Vídeo

                 

Semaforos

Asignacion #1 del laboratorio de Sistemas adaptativos.
En esta practica se requiere simular un sistema de trafico controlado por semaforos. La idea principal es evitar que los semaforos permitan una colisión al permitir el paso de los automóviles por vias abiertas al flujo que intersecten.
Objetivo

 Crear la simulación de un semáforo para una avenida con 3 sentidos, un sistema de trafico comun contiene 4 semaforos para controlar 4 sentidos. En este caso tomamos un modelo real con solo 3 sentidos.

Podemos ver en el dibujo que el sentido A puede avanzar de izquierda a derecha, con posibilidad de entrar al sentido de C y de B, con la condicion de que estos sentido esten deshabilitados para evitar colisiones.

Respecto al sentido B este puede avanzar de arriba hacia abajo, con la condicion de que A este deshabilitado.

El sentido C recorre de abajo para arriba siempre y cuando A & D esten deshabilitados. 


El sentido D recorre en diagonal desde arriba comenzando en el sentido B para pasar hacia el sentido de A siempre y cuando esten deshabilitados el A y el C.






Justificacion


A partir de el dibujo y la logica de como funciona un semaforo real, modelamos la solucion con algebra booleana, tomando en cuenta que cuando el semaforo esta en verde seria un uno logico y cuando el semaforo esta en rojo seria un cero logico.

Los casos especiales estan en la linea 2, que es cuando todos estan apagados y en gran cantidad de combinaciones se provocaria una colision. Solo tendriamos 6 casos posibles de combinaciones.

De los 6 casos disponibles, hicimos una minimizacion de ecuaciones dejando disponible 4.

A = !B && !C && !D
B = !A && C && D
C = !A && B &&  !D
D = !A && B && !C

De ahi concluimos que B y C son similares y pueden actuar al mismo tiempo, al igual que B y D. Asi que las combinaciones nos quedaron asi:

A
B && C
B && D

Puesto que D es una vuelta, le daremos prioridad en la ecuacion para terminar con una serie de ciclos solidos.

A -> B&&D -> B&&C

Ahora que los ciclos estan definidos, podemos darle las prioridades a cada ecuacion, esto lo haremos creando un numero aleatorio de carros, que a su vez sean comparados en cada sentido. Tomando en cuenta que los sentidos B,C,D estan ligados, se agarra el valor maximo de carros en esos tres sentidos y se compara con el valor resultante aleatorio de el sentido A, despues el sentido que tenga mayor cantidad de carros en espera es el que toma mas tiempo encendido.
La cantidad resultante de los carros afecta directamente al tiempo que dura encendido el semaforo correspondiente, recordando que los sentidos B,C,D estan ligados para evitar colisiones.

Codigo

Aqui dejamos lo que mas resalta del codigo, que es la forma en que se adapta este sistema.


El codigo completo lo pueden ver aqui

Resultados

Despues de analizar el programa durante su ejecuccion nos dimos cuenta que se logra evitar cualquier tipo de choque, se mejora un poco el rendimiento de los semaforos utilizando la logica difusa con respecto a la cantidad de carros que llegan a cada semaforo.

Conclusiones

Como conclusion obtuvimos que las colisiones no son probables, ya que la solucion logica no permite que los semaforos den paso a que los automoviles choquen. Y el hecho de que la cantidad de automoviles sea aleatoria no influye en la logica que evita que los carros colisionen, pero tampoco es la solucion optima para librerar el trafico lento.

Video

En el video se puede apreciar que la secuencia de los semaforos es A, despues B y D, se termina el D, y continuan el B y C. 

Los numeros que aparecen determinan la cantidad de carros en las direcciones. Como B,C,D dependen de ellos mismos gracias a las ecuaciones.