Max Hernandez

Laberinto - Ejemplo de Canvas en HTML5

jueves, 19 de abril de 2012

Tarea 4: Modelos caoticos


Buen día.

Esta semana tocamos el tema de los sistemas caóticos. Estos sistemas son muy importantes por que se encuentran en todos lados, por ejemplo en el ritmo del latido del corazón, en la dinámica de crecimiento poblacional, en el flujo de movimiento del agua de un río, etc.

La principal característica de estos sistemas caóticos es que estos tienen un alto grado de sensibilidad a las condiciones iniciales, por lo que si se intenta modelar y predecir, un pequeño cambio en las variables iniciales o las condiciones, hacen que los resultados cambien significativamente, un ejemplo de esto es el valor del dolar respecto al euro. Donde como se puede ver en la siguiente gráfica resultaria dificil modelar una función para tratar de estimar a largo plazo cual sería su valor.

[imagen obtenida de: http://news.bbc.co.uk/media/images/38137000/gif/_38137123_eurodollar2_300graph.gif]

Definición del caos de Devaney(1986):

Según este personaje el caos tiene tres componentes:

Transitividad

Dadas dos zonas cualesquiera del espacio donde esta definida
la función, existe un punto en la primera zona cuya órbita visita, en algún
momento, la segunda.

Dependencia sensible a las condiciones iniciales

Supongamos que x0 es un punto fijo un intervalo. Si para puntos cercanos
a x0 observamos que sus órbitas se mantienen , para toda iteración del intervalo,
cercanas a x0, entonces diremos que x0 es un punto fijo estable. Digamos que
nuestra idea de estabilidad en un punto fijo se refiere a que el comportamiento
de todas las órbitas que inician cerca de él se comportan casi como órbitas
de puntos fijos.

Densidad en el conjunto de puntos periódicos

Lo cuál quiere decir que cada punto en un intervalo de números reales existe en un conjunto de números periódicos (Puntos que vuelven a aparecer después de cierta iteración).


Automatas ceulares


Un modelo automata celular es un modelo que se representa una malla de células donde cada celula en un tiempo discreto finito puede tener un valor de 1 o 0. La función de su siguiente estado, depende directamente de la cantidad de vecinos y su valor.


[imagen obtenida de: http://atlas.wolfram.com/01/01/18/01_01_162_18.gif]



Los autómatas celulares pueden ser de cualquier dimensión y no necesariamente tienen que se representados con cubos o tablas, podrían representarse con cualquier grafo y los autómatas pueden ser fácilmente utilizados para simular un sistema.


















[imagenes obtenidas de: https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgHxlYU92r3RjKD1yrGUQM7YfQEbc2ayIaMupQnzVNxNl08KxAv_0GfDkBo5X3-WNsjCbEb2YO-ZWuIBU-4lmcsGYsAfU7WHu1XpuExnttCqRDgiTlH65vQlo51VLPzBnPe1YtcsP36qJyY/s400/ca_sur_06.jpg y http://upload.wikimedia.org/wikipedia/commons/8/86/Oscillator.gif]



El juego de la vida de Conway

El juego de la vida es un automata ceulular creado en 1970 por el matematico britanico John Horton Conway.  Este juego es de cero personas esto quiere decir que para interactuar con el se crean configuraciones iniciales y se obserban como avanzan en tiempos discretos.


Reglas del juego
El juego representa seres vivos que interactuan entre si, se representa por medio de una malla cuadrada de dos dimensiones, y cada celula puede tener dos estados, vivo o muerto. El sistema avanza en estados discretos y el estado siguiente de cada celula depende de la cantidad de vecinos en un estado anterior.
Las reglas del juego son las siguientes.
  1. Cada célula viva con menos de dos vecinos vivos, muere por desolación.
  2. Cada célula viva con dos o tres vecinos vivos sobrevive al siguiente estado.
  3. Cada célula viva con mas de tres vecinos vivos muere por sobrepoblación.
  4. Cada célula muerta con exactos tres vecinos vivos se convierte en una célula viva, por que se reproducen.
Para argumentar por que esté sistema se considera un modelo caótico, programé el juego usando Javascript y HTML5. El código es el siguiente:

function calcular_vecinos(filas, columnas, i, j, matrix, vecinos){
    vecinos[i][j] = 0;
    for( var i2 = i-1; i2<=i+1; i2++){
    	for( var j2 = j-1; j2<=j+1; j2++){
	    if( (i2>=0) && (j2>=0)  && (i2		if( ( matrix[i2][j2] == 1 ) && ( (i2 != i) || (j2 != j) ) )
		    vecinos[i][j] = vecinos[i][j]+1;
	    }
	}
    }


    return vecinos;
}

function siguiente_estado(filas, columnas, matrix, vecinos){
    for( var i = 0; i< filas; i++){
    	for( var j = 0; j< columnas; j++){
			vecinos = calcular_vecinos( filas, columnas, i, j, matrix,vecinos);
        }
    }

    for( i = 0; i < filas; i++){
    	for( j = 0; j < columnas; j++){
			if( matrix[i][j] == 1 ){
				if((vecinos[i][j] < 2) || (vecinos[i][j] > 3) )
                                    matrix[i][j] = 0;
			}else{
				if(vecinos[i][j] == 3) 
                                    matrix[i][j] = 1;
			}
		}
	}
    return matrix;
}

function dibujar(){
    for( var i=0; i        for( var j=0; j            if( matrix[i][j] == 1){
                context.fillRect( (i*pixel)+0.5, (j*pixel)+1.5, pixel, pixel);
            }
        }
    }
}


function clickListener(e) {
    if(activo == 0){
        espera();
	activo = 1;
    }else{
        activo = 0;
    }
}

var filas = 200;
var columnas = 100;
var matrix = Array(filas);
var vecinos = Array(filas);
var pixel = 2;

for(var i=0; i    matrix[i]=Array(columnas);
    vecinos[i] = Array(columnas);
    for( var j=0; j        matrix[i][j]=0;
        vecinos[i][j]=0;
    }
}

for( i=0; i    for( j=0; j        if(Math.random()<0.40)
            matrix[i][j]=1;
    }
}

canvasElement = document.createElement("canvas");
canvasElement.id = "cosa";
document.body.appendChild(canvasElement);
var canvas = document.getElementById("cosa");
canvas.width = 1+(filas*pixel);
canvas.height = 1+(columnas*pixel);
var context = canvas.getContext("2d");

context.fillStyle = '#F0DB4F';
context.fillRect(0,0, canvas.width,canvas.height);
context.lineWidth = 3;
context.strokeStyle = 'black';

canvas.addEventListener("click", clickListener, false);
var activo = 0;

function espera(){
    canvas.width = 1+(filas*pixel);
    canvas.height = 1+(columnas*pixel);
    dibujar(matrix, pixel);
    if( activo == 1)
        matrix = siguiente_estado(filas, columnas, matrix, vecinos);
    setTimeout("espera()", 400)
}


-
Ahora como ya sabemos un modelo caotico es muy sencible a un cambio en las condiciones iniciales (en este caso la configuración inicial) Para demostrar que el sistema elegí una plantilla del juego de la vida llamada "beacon" despues para comparar sus secuencias coloque una copia exacta de esta y agregue un pixel de mas, y en este link se muestra( dar click al cuadro amarillo para empezar la simulación y otro click para detenerla):
http://www.maxkalavera.iblogger.org/sensibilidad.html




Como podemos ver las secuencias cambian de forma drastica por un lado una configuración permanece ciclica cambiando cada estado, en cambio la otra imagen permanece inmóvil.

Por ultimo utilice valores aleatorios para generar una configuración inicial y el resultado son grupos de células con caracteristicas en sus secuencias diferentes para cada una, algúnas se repiten, otras cambian constantemente y otras solamente quedan inmóviles hasta que otro grupo interactué con ellas haciendo dificil predecir su comportamiento en un futuro relativamente lejano, muy similiar a lo que sucede en poblaciones de personas ( dar click al cuadro amarillo para empezar la simulación y otro click para detenerla).
http://www.maxkalavera.iblogger.org/conway_game_of_life.html



 
 Referencias:
 http://www.clausewitz.com/Complex/ChaosDemos.htm 
http://www.dynamics.unam.edu/NotasVarias/intro-sistemas.pdf http://books.google.com.mx/books?id=Hjua2EpKkKQC&pg=PA99&lpg=PA99&dq=simulation+heat+chaos&source=bl&ots=HMhTRO0aMt&sig=tivXw1cA90IDB8bhcIPRAedAxsI&hl=es&sa=X&ei=8fqRT9HOHqbC2wWGpdDoBA&ved=0CCkQ6AEwAQ#v=onepage&q=simulation%20heat%20chaos&f=false http://en.wikipedia.org/wiki/Conway%27s_Game_of_Life
 http://en.wikipedia.org/wiki/Cellular_automaton

martes, 17 de abril de 2012

Tarea de ensamblador - Cálculo de combinaciones

------------------------------
.LC0:
 .string "%i\n"

 .globl print
print:
 pushq %rbp
 movq  %rsp,  %rbp

 movq 16(%rsp), %rsi ;Mueve el valor de la memoria principal al registro %rsi
 movq $.LC0,   %rdi ;Mueve el puntero de el string al registro %rdi
 movl $0,   %eax ;Valor parametro para afirmar a printf que hay un solo valor parmetro
 call printf       ;Llama a la funcion printf

 leave
 ret


 .globl factorial
factorial:
 pushq %rbp
 movq  %rsp,   %rbp

 jmp .LF
.Factorial0:
 movq 16(%rsp), %rax ;Recupera el valor de la cima de la pila
 subq $1,  %rax ;Le resta uno al valor en %rax
 pushq %rax       ;Mueve el valor a la cima de la pila
 call  factorial      ;Llama a factorial
 popq %rax       ;Recupera el valor regresado por esta funcion

 movq 16(%rsp), %rdx 
 imulq %rax,  %rdx ;Este valor lo multiplica por el valor que recibio como parametro
 movq %rdx,  16(%rsp) ;Regresa el valor de la multiplicacion

 leave
 ret
.Factorial1:
 movq $1,  16(%rsp) ;Regresa el valor 1
 leave
 ret
.LF:
 cmpl  $1,   16(%rsp) ;Compara el valor en la memoria principal con 1
 jg .Factorial0   ;Si el valor es mayor que 1 pasa al bloque indicado

 cmpl $0,  16(%rsp) ;Si el valor es igual a 0 pasa al bloque indicado 
 je .Factorial1
 leave
 ret

.globl combinaciones
combinaciones:
 pushq %rbp  
 movq %rsp,  %rbp
 subq $24, %rsp

.L1:
 pushq 48(%rsp) ;Manda el segundo parametro recibido, como parametro para factorial
 call  factorial
 popq (%rsp)  ;Mueve el resultado a los primeros 8 bytes resevados
 
.L2:
 pushq 40(%rsp) ;Manda el primer parametro recibido, como parametro para factorial
 call factorial
 popq 8(%rsp)  ;Mueve el resultado a los siguientes 8 bytes resevados
.L3:
 movq 48(%rsp),  %rax
 movq 40(%rsp), %rdx ;Recupera los valores recibidos como parametros
 subq %rdx,  %rax ;Resta el primer parametro al segundo
 pushq %rax       ;Lo empuja a la cima de la pila
 call factorial      ;Obtiene su factorial
 popq 16(%rsp)      ;Lo recupera
.L4:
 movq 8(%rsp), %rax
 movq 16(%rsp), %rdx
 imulq %rax,  %rdx ;Multiplica los divisores

 movq (%rsp),  %rax
 movq %rdx,  %rbx
 movq $0,  %rdx
 idivq %rbx  ;Divide el factorial del primer parametro entre el divisor
 movq %rax,  48(%rsp) ;Pone el resultado en el primer parametro empujado a esta funcion

 leave
 ret

 
.globl main
 
main:
 pushq %rbp  ;Empuja el registro a la cima de la pila
 movq %rsp,  %rbp ;Mueve el registro %rsp a la cima de la funcion
 subq $32, %rsp ;Resta 32 al valor del registro %rsp
.M1:
 movq %rsi, %rax ;Mueve el valor puntero de %rsi a %rax
 movq %rax, (%rsp) 
 addq $8, %rax ;Mueve el puntero dos bytes arriba del stack
 movq (%rax), %rdi ;Esta vez mueve el valor en la memoria principal a el registro %rdi
 call  atoi  ;Manda a llamar al funcion atoi para convertir el valor en %rdi a entero 
 movq %rax, 16(%rsp) ;Recupera el valor regresado por atoi y lo mueve a la memoria principal
 
.M2:
 movq (%rsp), %rax ; recupera y convierte a entero el siguiente valor 
 addq $16, %rax 
 movq (%rax), %rdi 
 call  atoi  
 movq %rax, 24(%rsp)
.M3:
 movq 16(%rsp), %rax
 movq 24(%rsp), %rdx 
 pushq %rax  ;Empuja los parametros a la cima de la pila
 pushq %rdx  
 call combinaciones  ;Llama a la funcion de combinaciones
 
.M4:
 popq %rax  ;Recupera el valor que produce la funcion y luego lo manda a imprimir
 call print
 
 leave
 ret