SpinFoam

Mudanza...

2009-01-24T12:15:00.002-02:00

Finalmente anuncio la mudanza del blog a WordPress. No es que en general Blogger sea una mala opción, pero el soporte de LaTeX en WordPress es realmente muy práctico. Además, una vez que logré importar los posts (Guille: resultó más fácil de lo esperado...), desapareció uno de lso obstáculos que quedaban.

Esta es la nueva dirección del blog.
Este es el post inaugural (ya quedó un poco viejo).
Este es el único post nuevo (por el momento, obviamente).

No se olviden de actualizar sus feeds!

"Paradoja" resuelta

2009-01-21T22:07:00.003-02:00

Quería hacer unos comentarios respecto al problema del post anterior. Se mencionaba que, a una vela solar en movimiento, la luz le transmitía energía por efecto Doppler: la luz reflejada tendrá un espectro más rojizo (más frío) que la incidente. Pero una vela solar "en reposo" esto no le transmite potencia; como puede entonces comenzar a moverse...

Y la respuesta es verdaderamente simple: no necesita potencia para empezar a moverse :-D En efecto, supongamos que la vela solar se mueve con aceleración constante. Entonces tendremos para su energía cinética en función del tiempo la expresión:

T(t) = 1/2 mv² = 1/2 m(at)² = 1/2 ma²t²

Como la potencia no es más que un flujo de energía (en este caso la requerida para originar el aumento observado de la energía cinética), podemos obtener la potencia que la luz debería transmitir mediante una simple derivada:

P(t) = d/dt(T(t)) = ma²t

Puede observarse claramente que la potencia requerida inicialmente es nula y que esto se deriva de la relación cuadrática entre la energía cinética y la velocidad. Sorprendente, no?

Zenón 2.0 :-)

2009-01-09T09:10:00.005-02:00

Una vela solar es un sistema propuesto de propulsión para naves espaciales que utiliza la presión que ejerce la luz solar sobre una membrana (generalmente reflectiva). Puede representarse mediante el siguiente esquema (dibujado por Randall Munroe, el autor de xkcd):
Obviamente, como todo sistema físico, una vela solar debe obedecer la conservación de la energía. Por lo tanto su energía cinética debe adquirirse a partir de una correspondiente reducción en la energía de la luz incidente. En efecto, esto es lo que sucede y, en el caso de una vela perfectamente reflectiva, el efecto Doppler reduce la longitud de onda de los fotones reflejados de modo que la energía se conserve.

El problema es el siguiente: cuando la vela está estacionaria, no hay efecto Doppler y la potencia transferida a la vela es nula; como puede entonces comenzar a moverse? (Hint: T = 1/2 mv²)

La respuesta a este problema y un análisis más exhaustivo del comportamiento energético de las velas solares en unos días...

JavaScript

2008-12-28T11:08:00.006-02:00

Para practicar la puesta en práctica de las recomendaciones de Douglas Crockford respecto a como programar en JavaScript, me decidí por hacer una demostración en SVG del famoso "Arnold's Cat Map". Este mapeo consiste simplemente en aplicar repetidas veces a las coordenadas de un conjunto de puntos inicial la transformación

(x, y) → (x + y, x + 2y) mod 1 .

El "mod 1" es lo que indica que trabajamos sobre el toroide ℝ²/ℤ².

Si bien el mapa aplicado a valores reales es caótico y mezcla fuertemente el conjunto de puntos, se observa un fenómeno de recurrencia en las variantes discretas del problema (tal como la implementada). Para este caso particular en el que la imagen es de 32 X 32 pixels, la recurrencia se observa en el paso 24.

Nota de implementación: la imagen fue tomada de Wikipedia y editada y transformada a formato "JSON" utilizando PIL.

Porqué los espejos intercambian derecha e izquierda?

2008-12-22T18:40:00.003-02:00

Se cree comúnmente que los espejos "intercambian la derecha y la izquierda". Por ejemplo, la imagen especular de una persona diestra escribirá, aparentemente, con la mano izquierda. Esto nos llevaría a pensar que el espejo trata en forma diferente a las direcciones horizontales que a las direcciones verticales (porque no observamos que el espejo invierta "arriba y abajo").

Pero esto no es lo que en realidad "el espejo hace". La reflexión invierte las posiciones en la dirección perpendicular al espejo. Es por alguna razón psicológica que esto se observa como una rotación de 180° alrededor de un eje vertical compuesta con una inversión de derecha e izquierda.

La razón que se me ocurre para esto es que inconsciente observamos al reflejo como otra persona física; como físicamente las personas pueden rotarse pero no reflejarse, la visualizamos como una versión rotada de nosotros mismos con sus lados derecho e izquierdo intercambiados.

Esto plantea la pregunta de porqué visualizamos una reflexión derecha/izquierda pero no la reflexión adelante/atrás. Si bien no se me ocurre una respuesta directa a esta pregunta, probablemente se deba a la cuasi-simetría externa de las personas respecto al intercambio derecha/izquierda.

Lattice Boltzmann (actualización)

2008-12-20T10:59:00.004-02:00

Todavía no encontré el tiempo para dar una breve explicación de Lattice Boltzmann, pero logré mejorar notablemnete la eficiencia de la simulación. Puede hacerse checkout de la última "versión" hasta el momento en http://lattice-boltzmann-sdl.googlecode.com/svn/tags/0.03/.

A continuación muestro dos imágenes de la simulación, que está corriendo a unos 30 FPS en un solo core de un Intel Core Duo T2600 @ 2.16 GHz. Corresponden a la colisión de dos esferas de fluido en forma ligeramente oblicua.

The Emily Project

2008-12-17T19:54:00.005-02:00

La calidad de los renders sigue mejorando...

Actualización: El video normal no le hace justicia; puede verse el video en alta definición.

La subasta del dólar

2008-12-14T09:16:00.003-02:00

Desde el punto de vista formal se define a un juego como un conjunto de jugadores, cada uno de los cuales dispone de una serie de posibles acciones a tomar, y una forma de determinar cuanta recompensa recibe cada uno de los jugadores en base a las acciones que eligen todos ellos. Este formalismo no solo puede modelizar juegos como el ta-te-ti o el ajedrez, sino que puede aplicarse al análisis de situaciones hipotéticas tales como el conocido "dilema del prisionero".

Uno de los juegos que fueron definidos de este modo es el conocido como la "subasta del dolar" y fue creado por Martin Shubik en 1971 para dar un ejemplo simple del conocido proceso de escalada en los conflictos. El juego es muy simple: se subasta un dólar entre dos jugadores pero ambos deben pagar sus ofertas, lo que altera radicalmente el desarrollo de la subasta.

Supongamos que la oferta mínima y el incremento mínimo de las ofertas se establece en 0.05. Entonces, a primera vista, parece un excelente retorno ofrecer 0.05 a cambio del dólar; pero también lo será para el otro jugador ofrecer 0.10 y así el proceso puede seguir hasta que las ofertas hasta 0.95. Pero la fase más interesante ocurre a partir de este momento...

Supongamos que el jugador "A" hizo la última oferta de 0.95 después de que "B" hubiera ofrecido 0.90. Entonces "B" tiene dos opciones: puede aceptar perder 0.90 o puede ofrecer 1.00 y "salir hecho". El mismo análisis puede hacerlo "A" en caso de realizar "B" su oferta de 1.00: puede perder 0.95 u ofrecer 1.05 y perder 0.05... Esto lleva a una competencia en la que las pérdidas son potencialmente ilimitadas.

Uno podría pensar que este juego carece de relevancia práctica en si y que solo interesa como modelo de otras competencias que suceden en la realidad, pero eso sería incorrecto. Pueden verse más detalles acerca de Swoopo y su modelo de negocios en múltiples sitios. Quién dice que la teoría de juegos no es redituable? :-D

Lattice Boltzmann (con SDL!)

2008-12-08T23:48:00.003-02:00

Estoy trabajando en un nuevo proyecto personal: realizar una simulación de fluidos mediante el método conocido como Lattice Boltzmann y usando SDL para los gráficos. Si bien el objetivo último es lograr una buena performance, actualmente solo está funcionando la implementación "lenta" que voy a usar con propósitos comparativos (a unos 8 FPS con simple precisión en un Core Duo @ 2.16 GHz).

Hoy fue una experiencia bastante frustrante: empleé horas buscando un error en mi implementación de Lattice Boltzmann para descubrir finalmente que el problema estaba en las condiciones iniciales que estaba empleando... Más específicamente, no estaba cumpliendo con la condición CFL :-S

En las próximas semanas probablemente agregue algo más acerca de Lattice Boltzmann y, con suerte, tenga nuevos avances del proyecto.

Lissajous II

2008-12-03T13:25:00.010-02:00

(Continúa a este post.)

Es bien conocido que puede escribirse a todo número real como el producto de un número real de módulo menor que 1 y una potencia entera de un número mayor que 1. Por ejemplo, tomando base 10, tenemos:

234.435 = 0.234435 ∙ 10³

3.14159... = 0.314159... ∙ 10¹

1024 = 0.1024 ∙ 10⁴

Claramente podemos observar que el primer dígito del número aparece como el primer decimal en esta forma de representación. Utilizando algunas funciones tales como

⌊x⌋ = el mayor entero menor o igual que x,

⌈x⌉ = el menor entero mayor o igual que x y

{x} = la parte fraccionaria de x, igual a x - ⌊x⌋,

podemos expresar esto como

pd(x) = ⌊10^{log₁₀x}⌋,

donde pd(x) es la función que devuelve el primer dígito del número (esta expresión está limitada a numeros positivos, pero son los que interesan en nuestro caso). Esto nos indica que el primer dígito será:

1 si 0 ≤ {log₁₀x} < log₁₀2
2 si log₁₀2 ≤ {log₁₀x} < log₁₀3
...
9 si log₁₀9 ≤ {log₁₀x} < 1

Por lo tanto, la determinación de la primera cifra de la expansión decimal de un número se reduce a encontrar en cual de estos intervalos cae la parte fraccionarial de su logaritmo en base 10. Si aplicamos esto a las potencias de dos tenemos que

{log₁₀2ⁿ} = {n log₁₀2}.

Por consiguiente, la determinación de los posibles valores de los primeros dígitos de las potencias de dos se reduce a encontrar los sectores del intervalo [0, 1) donde caen las partes fraccionarias de los múltiplos de log₁₀2. Encontrar cuáles son estos sectores y cuál es la conexión de todo esto con las figuras de Lissajous quedará para el próximo post por razones de tiempo :-)

Lissajous I

2008-11-25T23:14:00.003-02:00

Es bien conocido que las representaciones decimales de las potencias de diez comienzan con un dígito '1' y terminan con un dígito '0' (exceptuando el caso trivial de 1⁰ = 1; se supondrán exponentes no nulos en el resto del post). Lo mismo sucederá, cualquiera sea el valor de n, con las representaciones en base n de las potencias de n.

Lo que no es tan claro es el comportamiento de los dígitos en una base dada, por ejemplo 10, de las potencias de un número distinto a la base. Si consideramos el caso de las potencias de 2 expresadas en base 10, podemos ver que terminarán en un dígito par ya que son números pares. Pensando un poco más, podemos ver que nunca terminarán en '0', ya que para ello deberían ser múltiplos de 10 y, por lo tanto, múltiplos de 5. Pero ciertamente quedaría en duda qué otros valores particulares podrán tomar los últimos dígitos...

Los que memorizamos potencias de dos como parte de nuestra actividad académica/profesional :-) podemos ver que:

2¹ = 2
2² = 4
2⁴ = 16
2³ = 8

y que, por lo tanto, todos los otros dígitos pares aparecen al final de las potencias de dos. Pero este es un proceso de enumeración exhaustiva, claramente insatisfactorio a la hora de obtener entendimiento de un proceso.

La primera incógnita que quedará planteada para el próximo post es determinar "que regla" siguen estos dígitos y, de mayor interés, qué regla siguen los dígitos más significativos; por ejemplo, puede una potencia de dos empezar con 9? El otro interrogante será ver que conexión tiene esto con las figuras de Lissajous...

Solución y otras cosas

2008-11-15T19:15:00.008-02:00

A continuación se muestra la solución al problema planteado en el último post. Para verla hacer click aquí.

El programa eventualmente se detiene, pero después de unas 2²⁰⁴⁰ iteraciones del loop externo. Por lo tanto, para fines prácticos, puede considerarse como un loop infinito... Es claro que devuelve cero, ya que tuvo que salir del loop externo para poder terminar. A continuación se describe con algo más de detalle el funcionamiento del programa.

Es claro que el único punto confuso es la acción de la línea "while (!++*p++);", el resto del programa es bastante normal. Para interpretarla, puede verse teniendo en cuenta la prioridad de los operadores que es equivalente a realizar "while (!(++(*(p++))));". Esto corresponde a:

Incrementar p devolviendo su valor original, que podemos llamar p'.
Incrementar el valor apuntado por p'.
Si el valor apuntado por p' es ahora 0, volver al paso 1. En caso contrario, salir.

Como buffer se inicializa con ceros al ser variable global y p apunta inicialmente a buffer[0], tenemos que en la primera iteración del loop externo:

(1) p <-- &buffer[1]
(2) buffer[0] <-- 1
(3) Sale porque buffer[0] != 0

En la segunda iteración tendremos:

(1) p <-- &buffer[1]
(2) buffer[0] <-- 2
(3) Sale porque buffer[0] != 0

Esto continuará hasta que buffer[0] sea 255. En ese momento sucederá lo siguiente:

(1) p <-- &buffer[1]
(2) buffer[0] <-- 0
(3) Vuelve a "1" porque buffer[0] == 0
(1') p <-- &buffer[2]
(2') buffer[1] <-- 1
(3') Sale porque buffer[1] != 0

Si se observa el comportamiento en detalle, puede verse que tenemos un contador en el que cada posición de buffer actúa como un dígito base 256. Para salir es necesario que al finalizar el loop interno p sea igual a q. Pero esto implicaría que se acaba de incrementar a buffer[255], lo que no sucederá hasta que hayan ocurrido 256²⁵⁵ == 2^8*255 == 2²⁰⁴⁰ iteraciones del loop externo.

En otro área completamente diferente, encontraron en México una caverna llena de extraordinarios cristales de yeso hidratado (sulfato de calcio):

En el sitio de National Geographic pueden observarse otras fotos espectaculares y más detalles sobre el descubrimiento (por ejemplo, el porqué de los trajes naranjas :-). (Via Robin Hanson.)

C Puzzle

2008-11-10T22:57:00.007-02:00

El problema es determinar si el siguiente programa:

termina de ejecutarse;
en caso de hacerlo, cuanto demora y qué devuelve al sistema operativo.


static unsigned char buffer[256];

int main(void)
{
  unsigned char *p, *q;
  q = (p = buffer) + sizeof(buffer);
  while (q - p)
  {     
      p = buffer;
      while (!++*p++);
  }
  return p - q;
}

Las respuestas a estas preguntas en unos días... :-D

Detectando dígitos en un 8051

2008-11-02T10:20:00.003-02:00

Uno de los problemas que aparecieron en un examen de Labo de Micros reciente (que le tomaron a mi hermano) indicaba hacer una "función" en assembly 8051 tal que detectara si el valor que se le pasaba era un dígito. Más especificamente, debían volver con C en 1 si y solo si el valor no era un dígito.

Yo siempre había pensado el problema de la forma obvia, algo así como:

no_es_digito:
clr C
subb A, #'0'
jc no_es_dig_end
subb A, #10
cpl C
no_es_dig_end:
ret

Pero a mi hermano le dijeron que podía hacerse con cinco instrucciones, lo que me hizo pensar en más detalle... hasta que vi que la resta no era la única solución. Eso me llevó al siguiente código:

no_es_digito:
add A, #(256 - '0')
add A, #(256 - 10)
ret

El primer add lleva, en forma modular, el valor desde el rango ASCII '0' ... '9' al rango 0x00 ... 0x09. En base a eso es simple ver que el segundo add dará como resultado C = 1 solo si el valor es 0x0a o mayor. Por lo tanto, solo dará C = 1 si el caracter pasado originalmente no cae en el rango '0' ... '9'.

No creo que pueda hacerse con dos instrucciones, ya que las instrucciones que alteran C en base al contenido del acumulador son aritméticas (según recuerdo!) y solo pueden "detectar" valores mayores o menores a uno especificado... pero el desafío queda abierto :-D

Sistemas de ecuaciones booleanos

2008-10-18T09:15:00.005-03:00

Hace unos días un compañero de la facultad (hola Guille!) me comentaba sobre una clase de problemas que suelen aparecer en los parciales de Matemática Discreta (al menos en la FIUBA). Recordaba que estos problemas consistían en encontrar una función booleana que de como resultado 1 si y solo si los valores de sus parámetros satisfacen un sistema de ecuaciones booleano y eso me hizo recordar un "método" que había desarrollado cuando la había cursado (aunque creo que no tuve ocasión de usarlo en el parcial).

Nota: Las "barras" que se suelen utilizarse para indicar complemento no se expresan fácilmente en HTML. Esto puede resolverse utilizando el operador "¬". Las otras dos operaciones pueden expresarse por "∧" (AND) y "∨" (OR). Por simplicidad, podemos asumir que "∧" tiene prioridad sobre "∨".

Para empezar podemos demostrar que dada una variable y satisfaciendo x ∧ y = 0 y x ∨ y = 1 sabemos que y = ¬x (o sea la unicidad del complemento). Una forma es viendo que:

(1) x ∨ y = 1 (Hipótesis)
(2) ¬x ∧ (x ∨ y) = ¬x ∧ 1 (Aplico la misma operación a ambos miembros)
(3) ¬x ∧ (x ∨ y) = ¬x (Definición de 1)
(4) ¬x ∧ x ∨ ¬x ∧ y = ¬x (Propiedad distributiva)
(5) 0 ∨ ¬x ∧ y = ¬x (Definición de complemento)
(6) x ∧ y = 0 (Hipótesis)
(7) x ∧ y ∨ ¬x ∧ y = ¬x (Reemplazando 6 en 5)
(8) (x ∨ ¬x) ∧ y = ¬x (Propiedad distributiva)
(9) 1 ∧ y = ¬x (Definición de complemento)
(10) y = ¬x (Definición de 1)

Otro "lema" que es útil indica que dados x e y tales que x ∧ y = 1, puede decirse que x = 1 y que y = 1. Una forma de demostrarlo es la siguiente:

(1) x ∧ y = 1 (Hipótesis)
(2) x ∧ y ∨ x ∧ ¬y = 1 ∨ x ∧ ¬y (Aplico la misma operación a ambos miembros)
(3) x ∧ y ∨ x ∧ ¬y = 1 (Propiedad absorbente)
(4) x ∧ (y ∨ ¬y) = 1 (Propiedad distributiva)
(5) x ∧ 1 = 1 (Definición de complemento)
(6) x = 1 (Definición de 1)

Por simetría podemos ver que y = 1 y podemos evitar demostrar la propiedad absorbente para poder llegar alguna vez al tema a tratar :-)

Ahora, podemos ver a todo sistema de ecuaciones como una serie de igualdades entre funciones que requieren satisfacerse. Por ejemplo:

f1(x, y, ...) = g1(x, y, ...)
f2(x, y, ...) = g2(x, y, ...)
f3(x, y, ...) = g3(x, y, ...)
...

Ahora, como sabemos que x ∧ y = 0 y x ∨ y = 1 implican x = ¬y y que x ∧ y = 1 implica que tanto x como y son iguales a 1, podemos expresar una igualdad arbitraria a = b como ¬(a ∧ ¬b) ∧ (a ∨ ¬b) = 1 aplicando lo siguiente:

Ida

(1) a = b (Hipótesis)
(2) a = ¬(¬b) (Propiedad involutiva del complemento)
(3) a ∧ ¬b = 0 (Definición de complemento)
(4) a ∨ ¬b = 1 (Definición de complemento)
(5) ¬(a ∧ ¬b) = ¬0 (Aplico la misma operación a ambos miembros)
(6) ¬(a ∧ ¬b) = 1 (Aplico ¬0 = 1)
(7) ¬(a ∧ ¬b) ∧ (a ∨ ¬b) = 1 (Aplico ∧ miembro a miembro sobre 4 y 6)

Vuelta

(1) ¬(a ∧ ¬b) ∧ (a ∨ ¬b) = 1 (Hipótesis)
(2) ¬(a ∧ ¬b) = 1 (Propiedad demostrada anteriormente)
(3) a ∨ ¬b = 1 (De 1 por propiedad demostrada anteriormente)
(4) ¬¬(a ∧ ¬b) = ¬1 (Aplico la misma operación a ambos miembros)
(5) a ∧ ¬b = ¬1 (Propiedad involutiva del complemento)
(6) a ∧ ¬b = 0 (Aplico ¬1 = 0)
(7) a = ¬¬b (Aplico otra propiedad demostrada anteriormente sobre 3 y 6)
(8) a = b (Propiedad involutiva del complemento)

Si omitimos que no demostramos ni la propiedad involutiva del complemento ni que ¬0 = 1 (las demostraciones son simples, quedan como ejercicio para el lector :-), sabemos como transformar una ecuación arbitraria en una igualada a 1. Ahora podemos aplicar que x ∧ y = 1 implica que x = y = 1 para expresar el sistema de ecuaciones anterior como:

¬(f1(x, y, z, ...) ∧ ¬g1(x, y, z, ...)) ∧
(f1(x, y, z, ...) ∨ ¬g1(x, y, z, ...)) ∧
¬(f2(x, y, z, ...) ∧ ¬g2(x, y, z, ...)) ∧
(f2(x, y, z, ...) ∨ ¬g2(x, y, z, ...)) ∧
¬(f3(x, y, z, ...) ∧ ¬g3(x, y, z, ...)) ∧
(f3(x, y, z, ...) ∨ ¬g3(x, y, z, ...)) ∧
... = 1

Esto cumple en forma automática el objetivo del problema aunque puede ser algo tedioso...

Me pasó otra vez...

2008-08-02T09:56:00.003-03:00

...Google insiste en confundirme con un bot. No se que es lo que confundirá a sus algoritmos de detección, aunque sospecho de mi tendencia a abrir múltiples pestañas cuando veo una lista de links :-)

Por si fuera poco, el CAPTCHA también me clasificó como "no humano", ya que realmente me resultaba difícil ver que es lo que decía. Tengo la sospecha de que navegar por Internet en el futuro va a ser realmente interesante...

spice3f5 para Visual C++

2008-07-18T11:03:00.003-03:00

Acabo de agregar a la página de mi proyecto de Tesis una versión de spice3f5 compilable con Microsoft Visual C++ 2008. Esto permite realizar fácilmente análisis de una netlist cualquiera (aunque no incluye manual de uso :-)

Un problema de probabilidad

2008-07-02T14:32:00.003-03:00

En un juego, se presentan a una persona dos sobres. Sabe que uno de ellos contiene una cantidad desconocida de dinero 'A', y que el otro contiene el doble de esa cantidad, pero el jugador desconoce "cuál es cual". Se le dice que puede llevarse solo uno de los sobres y que debe llevarse el último sobre que abra.

La pregunta es: después de haber elegido y abierto un sobre, le conviene cambiarlo por el otro?

La respuesta intuitiva es "no", ya que ver el contenido del sobre no nos permite discriminar entre el caso en que elegimos el sobre con la cantidad A y el caso en que elegimos el sobre con al cantidad 2A. Al no tener evidencia proveniente de ver el contenido del sobre, el intercambio nos sería indiferente.

Ahora supongamos que calculamos el valor esperado del contenido del sobre no abierto, al que denominaremos "sobre 2". Si llamamos B al contenido del sobre abierto, el sobre 2 puede tener contenido B/2 o 2B. Asumiendo la indiferencia mencionada anteriormente, el valor esperado del contenido del sobre 2 sería:

E(contenido sobre 2) = 1/2 B/2 + 1/2 2B = B/4 + B = 5/4 B

Esto implicaría que siempre nos sería conveniente realizar el intercambio!

Más detalles sobre el problema y sus implicaciones en Wikipedia...

Factories en C++

2008-04-30T12:53:00.005-03:00

Las implementaciones normales de factories en C++ suelen introducir la necesidad de modificar la clase Factory o su inicialización para cada clase que se agrega. Los intentos de evadir esta centralización utilizando la inicialización estática suelen ser algo como lo que aparece en el ejemplo factory_mal (es claro que hay algo mal :-) .

Este ejemplo utiliza la inicialización de variables globales para realizar el registro de los factory methods. En muchos casos esto parece funcionar, de hecho me acaba de funcionar al probarlo, pero contiene un error grave: asume un orden de inicialización de objetos estáticos entre distintos archivos (bueno, "unidades de traducción").

El problema en que no puede suponerse que los distintos Registrators vayan a inicializarse después que Factory::cm_. Si los Registrators se inicializan primero, Factory::registrate() accederá a un map no inicializado, probablemente llevando a un segmentation fault.

La solución a esto es la misma que la aplicada en el Singleton de Meyers: utilizar una variable estática dentro de un método. De este modo podemos garantizar que el objeto estará inicializado cuando sea utilizado.

Obviamente esta solución no maneja los problemas con múltiples threads, ni arregla mágicamente los problemas de diseño que puedan ser provocados por el uso indebido de singletons, pero soluciona el problema de la inicialización.

Relatividad en 6 minutos

2008-04-05T09:42:00.003-03:00

(Vía John Walker)
Sí, un video musical por Max Tegmark! No puedo imaginarme algo así en la FIUBA aunque, en realidad, tampoco lo imaginaba en el MIT :-D

El paper con la letra...

Un robot distinto

2008-04-03T09:24:00.004-03:00

BigDog: un robot que parece "útil". Acostumbrado a ver la forma vacilante en que suelen caminar los robots me impresionó mucho la estabilidad y adaptabilidad que despliega BigDog. Tal vez hay razones para el optimismo en la robótica :-)

Muere Arthur Clarke a los 90 años

2008-03-19T07:19:00.003-03:00

Probablemente, su idea más conocida es la que apareció en esta tapa de diario, allá por el año 1946 y en una revista en el año 1945 con más detalle. Un anticipo de DirectTV... aunque con tripulaciones yendo a cambiar las válvulas :-)

Probablemente esta mezcla de aciertos y desaciertos sea inherente a tratar de predecir tecnologías futuras; como dice la frase, "es difícil hacer predicciones, sobre todo acerca del futuro". Probablemente allá por el año 2200 se reirán de algunas de las predicciones que se hacen hoy día acerca de la nanotecnología.

Proyecto para Labo de Micros

2008-03-17T08:33:00.005-03:00

Acá está todo el software del proyecto que hicimos (junto con Mariano Beiró) para la materia Laboratorio de Microcomputadoras: un juego de Ta-Te-Ti capaz de conectarse a cualquier televisor (con audio incluido!). Una de las cosas más particulares que tenía el software era el uso de un tabla comprimida con Huffman para determinar que jugada realizar en base a la posición del tablero. Algunas fotos:

La imagen proyectada sobre una PC cuando hicimos la presentación (como la salida era video compuesto la tomaba sin problemas).

Una vista de la plaqueta principal.

Graficando funciones discontinuas con Mathematica

2008-03-16T22:55:00.011-03:00

Mientras estaba tratando de ilustrar el comportamiento de las funciones racionales elípticas dentro de la Tesis, me encontré con uno de los problemas del comando Plot[] del Mathematica. Este comando, al ir conectando puntos donde evalúa a la función, termina dibujando una línea en donde debería haber una discontinuidad. Por ejemplo, si uno ejecuta el comando Plot[1/(x-1),{x,-3,3}] obtiene el siguiente resultado:

Puede verse claramente que hay una línea vertical en x = 1.

Después de encontrar en la Web varias opciones que no me resultaban satisfactorias, tales como actualizar a la versión 6 o dividir el gráfico en segmentos con dominios donde la función es continua (estaba trabajando con una función con 4 polos), decidí acotar el valor de la función y reemplazar los valores superiores con valores indeterminados.

Esta solución aplicada al problema de mostrar correctamente al gráfico anterior quedaría como:

f[x_]:=1/(x-1);
fp[x_]:=Module[{},
ret=f[x];
If[Abs[ret]>30,Indeterminate,ret]];
Off[Plot::plnr];
Plot[fp[x],{x,-3,3}];
On[Plot::plnr];

Los comandos Off[] y On[] desactivan y activan respectivamente la emisión del error Plot::plnr, producido por la función Plot[] al encontrarse con valores no numéricos.

En otros temas, más allá de las funciones elípticas, dos interesantes fotos de objetos de oro sólido (particularmente apropiados con el oro a más de $100000 el kg :-)

Una pepita de oro de más de 4 kg.
Un ladrillo de 220 kg de oro (más de $22000000 en la actualidad).

Una cosa a destacar es que 220 kg de oro solo tienen un volumen de 11.4 litros, ya que el oro es uno de los elementos más densos (si, más que el plomo). O sea que podríamos meter $22000000 en un cubo de 23 cm de arista... aunque sería algo difícil de levantar.

Intel 4004 - 36º aniversario

2007-11-14T23:48:00.000-03:00

Me acabo de enterar que Intel publicó el esquema de circuitos del 4004, que fue (más allá de un cierto debate...) el primer microprocesador. Obviamente, con 2300 transistores y 740 kHz de reloj no podía hacer mucho; de hecho consigue hacerme sentir afortunado de estar programando un clon del 8051 :-) Aunque al menos el 4004 terminaba una instrucción en 8 ciclos...

Ratas topo!!

2007-10-11T12:12:00.000-03:00

Es un animal muy particular, que habita en Etiopía, del que no conocía la existencia. Ciertamente tiene un aspecto poco común.

Subst++

2007-09-18T10:37:00.000-03:00

Una funcionalidad de Windows (y DOS!) poco conocida es el comando subst, que permite asignarle una letra de unidad a un path. De ese modo, por ejemplo, subst X: "C:\Documents and Settings\user\Mis Documentos\Visual Studio 2005\Projects\" permite acceder a lso proyectos de Visual Studio como si estuvieran en el directorio raíz de una unidad con la letra X. Esto lo vi por primera vez en el sitio de Poco, un framework de red para C++.

Hablando ahora de algo completamente diferente, una imagen interesante de la Segunda Guerra: cuando retiran la bandera del portaaviones japonés Zuikaku (uno de los que había participado en el ataque a Pearl Harbor), antes de que se hunda. Para el momento en que se sacó esa foto, ya era bastante notable la inclinación de la cubierta debido al ingreso de agua (escora para los que conocen terminología náutica :-). Quince minutos después, la mitad de los tripulantes (más de ochocientos) murió cuando, finalmente, el portaaviones se dio vuelta y hundió.

Siguiendo con temas náuticos, este el motor diesel más grande del mundo, con 108,920 hp de potencia. Tiene una eficiencia de más del 50% en su régimen óptimo, ampliamente mayor que la eficiencia de los motores de automóvil que suele estar alrededor de 20%. Esta diferencia está dada fundamentalmente por la operación en un régimen menos variable, y las menores pérdidas de calor debido a la escala del motor.

"Dar vuelta" una esfera

2007-09-16T23:13:00.000-03:00

Acabo de ver un video muy interesante sobre como dar vuelta una esfera, o sea intercambiar su cara interior con la exterior.

Puede verse en:

http://video.google.com/videoplay?docid=-6626464599825291409

Wikipedia en inglés: 2000000 de artículos

2007-09-09T22:48:00.000-03:00

Hoy la versión en idioma inglés de Wikipedia superó los dos millones de artículos. A pesar de que ciertamente puede discutirse la calidad de algunos de los artículos, el hecho de que una enciclopedia basada en contribuciones de los usuarios funcione tan bien como lo hace es verdaderamente digno de destacarse.

Me enteré hace unos meses que existe una página destinada al mantenimiento de la infraestructura técnica de Wikipedia que, como podría suponerse, es bastante grande. Además es especialmente interesante por la apertura respecto al funcionamiento, que nos permite ver cosas que no podemos conocer respecto a Google, por ejemplo.

En curiosidades: ¿se imaginan un edificio sin ventanas? ¿O qué a principios del siglo XX Bayer vendía heroína para calmar la tos en chicos?

Comentarios sobre una noticia

2007-09-06T08:07:00.000-03:00

Estaba viendo esta noticia de Yahoo, proveniente de Infobae que supuestamente hablaba sobre "Diez misterios que la ciencia todavía no pudo develar". Debo admitir que, si bien no esperaba ver algo así como las de John Baez, no estaba preparado para ver la lista de estupideces que aparecían... O sea, ¿hay gente que cree en "Pie Grande" y en los fantasmas?

En fin, supongo que viendo la clase de cosas que se publican incluso en revistas de divulgación científica no debería extrañarme mucho. O sea, si los editores de una revista dedicada a divulgar el conocimiento científico no conocen la conservación de la cantidad de movimiento, que se puede esperar...

Es deprimente.

Promoción de enteros en C++

2007-09-04T07:13:00.000-03:00

Un problema particularmente molesto me ocurrió ayer mientras programaba el sistema de evaluación de individuos de la tesis. Había escrito el siguiente fragmento de código:


for (int i = 0; i < reqs.size() - 1; i++)
 std::cout << reqs[i].first.toString() << " - ";

cuya idea es, básicamente, imprimir todos los elementos de
reqs a excepción del último, para que no quede un guión colgando al final.

Al ejecutar el código, funcionaba bien en general; pero al probarlo con un vector vacío, fallaba con un error indicando acceso a una posición inexistente. Después de un tiempo de meditación (excesivamente largo!), pude darme cuenta de lo que originaba el problema. reqs.size() devuelve un tamaño del tipo size_t, que por lo general es un typedef de unsigned int. Al restarle uno, de acuerdo a las reglas de promoción, se le resta como si fuera una resta de unsigned ints, por lo que la resta actuaba en forma modular y terminaba tratando de acceder a la posición 2³² - 1 (la que obviamente no existía en el vector).

En otro contexto completamente diferente, una tesis interesante de un graduado de la CMU en la que calcula, en base a un diseño concreto, el costo que tomaría absorber el dióxido de carbono de la atmósfera. Yo consideraba que era algo que debía ser completamente infactible, pero parece ser que podría hacerse por un costo de U$S 200 por tonelada de CO₂. Obviamente es más costoso que secuestrarlo en una central térmica, pero podría ser una solución para la captura de fuentes distribuidas, como es el caso del transporte automotor en general.

Post de retorno: desarrollo de circuitos

2007-08-21T21:28:00.001-03:00

Bueno, pasó bastante tiempo desde la última actualización y no quería llegar a un mes sin posts... Estas últimas semanas estuve ocupado terminando trabajos prácticos finales para varias materias, pero esta pude empezar nuevamente con el trabajo de la tesis. Más específicamente, comenzando a programar el módulo de evaluación.

Este módulo es central para el sistema, ya que debe transformar la descripción del individuo en un circuito con objeto de que pueda obtenerse su transferencia con el SPICE y compararla con la deseada. Esta transformación, que puede verse animada en el sitio de John Koza, consiste en interpretar el cromosoma como una serie de instrucciones que gobiernan el "crecimiento" de un circuito.

Como en el sistema que estoy desarrollando un cromosoma es un array de bytes y debo representar con él un árbol, tenía que decidirme por una codificación. Después de pensar varias opciones, elegí utilizar una codificación prefija por la simplicidad de su "evaluación" recursiva. También evalué la posibilidad de no efectuar la recursión y reemplazarla por iteración, pero decidí seguir el precepto de Knuth respecto a la optimización prematura.

La otra decisión de codificación era respecto al circuito: implementar mi propia representación o utilizar Boost. En base a mis experiencias previas con grafos, elegí utilizar boost::adjacency_list; no por razones de performance, sino para evitar los posibles bugs y tiempo desperdiciado.

Para terminar, un interesante post de Stephen Wolfram (el creador del Mathematica) sobre los diseños de puentes, a la luz de la famosa caída de uno en Estados Unidos.

GLUT y su eventual sustitución

2007-07-25T07:54:00.000-03:00

Estas últimas semanas estaba tratando de recordar un poco como usar OpenGL y, a diferencia de lo que había hecho en ocasiones anteriores, probé utilizar algunas bibliotecas para facilitar el trabajo (algo se aprende al pasar los años :-)

Empecé utilizando GLUT, ya que tiene una enorme base de ejemplos desde los que partir. Pronto me encontré con un inconveniente: yo programo normalmente esta clase de aplicaciones en C++, pero GLUT fue diseñada para utilizarse con C y, por desgracia, algunas de sus callbacks tienen el prototipo void callBack(void). Esto me hacía imposible esconder a this y me obligaba a utilizar un punto de acceso central, probablemente un singleton (ahora que lo pienso mejor, podría haber implementado alguna clase de dispatcher pero, como verán, no era realmente necesario).

Al no encontrar dicha "solución" muy satisfactoria (años de propaganda anti-singleton rindiendo frutos), probé con varias adaptaciones o extensiones de GLUT para C++, siendo GLT la que atrajo más mi atención. Sin embargo, carecía notablemente de documentación e involucraba múltiples DLLs.

Me disponía a seguir probando con GLUT pero, al consultar algunos ejemplos de "procedural textures" de Sean O'Neil (lamentablemente su sitio ya no funciona, pero pude encontrar sus ejemplos en The Wayback Machine), me encontré con SDL. Ya había escuchado mencionarla, pero nunca pensé que fuera tan simple de utilizar; en unos minutos tenía corriendo mi primer ejemplo y, a partir de entonces, me convertí totalmente a SDL :-)

Sigue siendo C, pero su sistema de manejo de eventos, paradójicamente basado en un loop explícito al estilo Windows, es fácil de integrar con C++. Además gana en todas las otras áreas, ya que incorpora un control más directo de la resolución de la pantalla y la documentación, si bien breve, es la necesaria para empezar a utilizarla rápidamente.

Cuando siga con mi ejemplo de OpenGL, veré que tan satisfactoria resulta en general...

En otras áreas:

Tres blogs interesantes:

el de Herb Sutter, miembro del comité de C++;

el de Andrew Koenig, otro miembro de dicho comité

y el de Ysaneya (Flavien Brebion), que está trabajando en un juego con gráficos muy impresionantes.

Una ilusión óptica.
Una imagen del datacenter de Internet Archive.

Dia del Amigo y otras cosas

2007-07-20T22:12:00.000-03:00

Breves comentarios:

Al ser hoy el Día del Amigo y, por lo tanto, aniversario de la llegada de la misión Apollo 11 a la Luna, estaba mirando el artículo de Wikipedia sobre el tema, seguro de que no podía decir nada que no conociera, ya que había leído bastante sobre el tema, me encontré con esto. Ciertamente tomaban en cuenta todas las posibilidades con antelación :-I

Otro tema que vi es la interesante máquina que juega al Ta-Te-Ti hecha con "Tinkertoys" (con pequeñas excepciones). Puede verse en forma libre un excelente y muy detallado artículo sobre ella.

Para despedirme, la épica pelea en Hockey entre canadienses y soviéticos (año 1987) en YouTube.

Juego de las damas resuelto!

2007-07-20T08:12:00.000-03:00

El juego de las damas fue resuelto! (Como era de esperar el resultado del juego perfecto es empate.)

Es un resultado interesante porque es, por lejos, el juego más complejo que ha sido resuelto completamente. Aparentemente al ajedrez le queda bastante tiempo todavía, aunque la teoría de los finales de ajedrez ha sido modificada en formas importantes por las búsquedas exhaustivas realizadas por Ken Thompson (el mismo del Unix!), que indicaron, por ejemplo que ciertos finales de rey, dama y peón contra rey y dama (denominados KQPKQ) requerían más de 50 movidas para el mate.

Descripción del tema de la tesis y otras cosas

2007-07-19T23:19:00.001-03:00

Bueno, antes de seguir con los temas del día, voy a hablar un poco de cual es el tema de mi tesis. El tema es la "Utilización de estrategias de selección de población para el diseño de filtro analógicos pasivos utilizando programación genética", pero ¿qué significa?

Bueno empecemos con la programación genética (mucha más información sobre el tema, como siempre, puede encontrarse en Wikipedia o en Google). La programación genética es una técnica para resolver problemas de optimización que se basa en realizar una "evolución artificial" de una población de programas, con el objeto de seleccionar al que dé la solución más conveniente al problema planteado. Se diferencia de los algoritmos genéticos en que el genoma no se interpreta en forma estática, sino que se ejecuta con una máquina virtual (limitada, lógicamente, no es ni HotSpot ni CLR! :-) Voy a hablar más de este tema (uno de los más importantes en un sistema de programación genética) posteriormente, cuando esté implementando la mencionada VM.

Los filtros analógicos pasivos son circuitos electrónicos cuyo objetivo, tal cual lo indica el nombre, es "filtrar" una señal, eliminando ciertos componentes de la misma. Se denominan analógicos porque operan con una representación continua de la señal; esto los diferencia de los filtros digitales que lo hacen con una representación en tiempo discreto. Finalmente son pasivos porque solo utilizan tres clases de componentes: resistores, capacitores e inductores, ninguno de los cuales "entrega energía" a la señal (la definición estricta de pasividad es algo compleja). A pesar de que no figura en el nombre, estos filtros son lineales, lo que implica que la respuesta a la suma de dos señales es al suma de las respuestas que daría a cada señal por separado.

El realizar todas esas generaciones de evolución con poblaciones que pueden llegar a tamaños considerables es computacionalmente costoso. Si bien hoy día es en general ventajoso intercambiar tiempo del programador por tiempo de máquina, como lo muestra la gran popularidad de lenguajes tales como Python, una tarea suficientemente compleja puede vencer incluso al crecimiento exponencial del poder de cálculo. Por ello es importante tener métodos relativamente sofisticados para elegir a los circuitos de la población con mejores perspectivas de acercarnos a la solución. Más adelante hablaré sobre al naturaleza de estas estrategias.

Bueno ahora a los links del día:

Brian Beckman: The Physics in Games - Real-Time Simulation Explained

Photo Tourism: Exploring Photo Collections in 3D (funciona con Firefox)

En el próximo post: GLUT - arcaica o práctica :-D

Post inaugural

2007-07-18T18:35:00.000-03:00

En este blog pienso desarrollar ideas relacionadas con el tema de mi tesis, de forma de obtener realimentación al respecto. También, lógicamente, tendrán su lugar las ideas no directamente relacionadas con la tesis.

Espero que no se convierta en un "sumidero de tiempo" :-)