Azar, probabilidad y noise

Una tirada de dados jamás abolirá el azar

Sthéphane Mallarmé

El paso de la física determinista a la física de probabilidades implicó un cambio de pensamiento que ha repercutido más allá de la ciencia. Las relaciones entre orden, caos y aleatoriedad influyeron fuertemente en el mundo del arte, llegando a ser un motor de creación artística para las propuestas experimentales de los años 60 y 70, como las composiciones musicales de John Cage, que definió el proceso de creación de la pieza William Mix (1953) del siguiente modo:

A través de medios elaborados al azar, determiné previamente cuáles de aquellas categorías tenían que agruparse, y qué parámetros había que modificar. Se llamó a las categorías A, B, C, D, F; y la agrupación de estos elementos venía determinada por operaciones al azar del I Ching (Kostelanetz 1973, 36)

Esta descripción bien parece un esquema de programación; como todos los procesos aleatorios, tiene como particularidad producir formas o sonidos que no pueden conocerse de antemano, pero el proceso no está dejado al azar en su totalidad, sino que marca un esquema dentro del cual el azar establece las relaciones.

Azar y aleatoriedad permiten observar cómo la incertidumbre entra en el mundo de las matemáticas, dado que la aleatoriedad se define como todo aquello que «bajo el mismo conjunto aparente de condiciones iniciales, puede presentar resultados diferentes», rompiendo el patrón causa-efecto. En el campo de las matemáticas se han desarrollado la teoría de la probabilidad y los procesos estocásticos para caracterizar las situaciones aleatorias.

En programación, todos los lenguajes contemplan funciones random -aleatoriedad- para representar estas situaciones. En Lua-Mosaic, se puede usar  la función of.random(float,float) cuyos parámetros definen el rango de dos valores, entre los que el sistema elegirá uno al azar, cuando sólo tiene un parámetro el rango va de 0 a ese valor. Esta función suele utilizarse para generar formas o sonidos menos definidos y que presentan una configuración distinta cada vez que se activan, pudiendo reflejar mejor un carácter orgánico.  En el siguiente ejemplo, un número determinado de puntos se distribuyen siguiendo una diagonal de 45º pero que fluctúan a un lado y otro con una doble aleatoriedad que va incrementando sucesivamente el rango de fluctuación.

--
--
--  ----------------------------------------------------------
--  Mosaic | OF Visual Patching Developer Platform
--
--  Copyright (c) 2018 Emanuele Mazza aka n3m3da
--
--  Mosaic is distributed under the MIT License. This gives everyone the
--  freedoms to use Mosaic in any context: commercial or non-commercial,
--  public or private, open or closed source.
--
--   See https://github.com/d3cod3/Mosaic for documentation
--  ----------------------------------------------------------    E-4-17
 
-- Random Regulado

--

totalPuntos = 800
rango = 0

---------------------------------------

function setup()

end
----------------------------------------

function update()

end

---------------------------------------

function draw()
  -- draw background first 
  mosaicBackground(255,255,255,255) -- fondo blanco sin transparenciaco
  
  of.setColor(0)	
  rango = 0
  for i = 1, totalPuntos do
    for j = 1, totalPuntos do	
      if i == j then
        of.drawCircle(i + of.random(-rango, rango), j+ of.random(-rango,rango),2)
        rango = rango + of.random(-1, 1.5)
      end
    end
  end
end

La funciónfor tiene sólo dos declaraciones: valor inicial de la variable i, y test (hasta que i sea mayor o igual a totalPuntos); al no tener la tercera se entiende que es 1, por lo que su acción se reduce  a recorrer todos los valores entre 1 y 800. Cada vez que incrementa 1, el otro for recorre sus 800 pasos y vuelve el primer for a sumar uno más…

En la función of.drawCircle(), las coordenadas x e y alteran esa distribución uniforme al fluctuar un número indeterminado de pixels a un lado y otro de esa dirección como consecuencia de la función of.random(), cuyos valores están a su vez sujetos a la indeterminación de otra función of.random()  que tiende a incrementarlos.    

Aunque hagamos un random de random recursivo, la función of.random() produce lo que se conoce como «una distribución «uniforme» de números».

Los números aleatorios que recibimos de la función  random() no son verdaderamente aleatorios y por lo tanto, se conoce como «pseudo-aleatorios». Son el resultado de una función matemática que simula el azar. Esta función daría lugar a un patrón durante un tiempo, pero ese período de tiempo es tan largo que para nosotros, parece tan bueno como el azar puro! (Shiftman 2012, 7)

La conjunción de azar y probabilidad busca producir una distribución «no uniforme» de números aleatorios, reflejando que en ningún sistema todos los elementos son iguales, ni tienen las mismas condiciones.

Pensemos de nuevo en la descripción de John Cage. Para trabajar con el azar Cage establece 6 categorías para los sonidos: A (sonidos de la ciudad), B (sonidos del campo), C (sonidos electrónicos), D (sonidos producidos de forma manual), E (sonidos producidos por el viento) y F («pequeños» sonidos que deben ser amplificados), y además establece en todos ellos otros parámetros vinculados al tono, timbre e intensidad. Después tira las monedas del I Ching para que el azar decida la composición a partir de ese diagrama de relaciones. No se trata de una aleatoriedad uniforme entre todos los sonidos, sino que opera articulándose con un contexto de relaciones condicionales.

Incluso las decisiones que se puedan tomar siguiendo el ejemplo más sencillo del azar, tirar una moneda al aire, tiene condiciones. En principio existe una equiprobabilidad, es igual de probable que salga cara o cruz: 1/2 = 50%

Lanzar la moneda una sola vez, nos sitúa ante eventos independientes, cuyo resultado no está condicionado ni tiene efecto en la probabilidad de que ocurra cualquier otro evento. Pero si lanzamos la moneda dos veces, la probabilidad de que salga cara en ambos sucesos cambia. Según los principios básicos de probabilidad, que 2 o más eventos independientes ocurran juntos o en sucesión, es igual al producto de sus probabilidades marginales:  1/2 * 1/2 = 1/4 el 25% 

En el caso de tres tiradas (…, el I Ching implica 6 tiradas de 3 monedas cada vez): 1/2*1/2*1/2 = 1/6 el 16’6%.

Así llegamos a que la probabilidad de que suceda un evento está condicionada a que haya ocurrido, o no, otro evento.

Daniel Shiffman propone otro ejemplo particular dentro del campo del azar, el Camino aleatorio (Random Walks), que de algún modo mantiene también relación con las acciones artísticas psicogeográficas de los Situacionistas.

Camino aleatorio es una formalización matemática de la trayectoria que resulta de hacer sucesivos pasos aleatorios. Por ejemplo, la ruta trazada por una molécula mientras viaja por un líquido o un gas, el camino que sigue un animal en su búsqueda de comida, el precio de una acción fluctuante y la situación financiera de un jugador pueden tratarse como un camino aleatorio. El término Camino aleatorio fue introducido por Karl Pearson en 1905. Los resultados del análisis del paseo aleatorio han sido aplicados a muchos campos como la computación, la física, la química, la ecología, la biología, la psicología o la economía (Wikipedia, Camino aleatorio).

El siguiente ejemplo muestra la programación de un Camino aleatorio tradicional que se inicia en el centro de la pantalla y a cada paso elige al azar una entre las 8 opciones, que en coordenadas oscilará entre +1 y -1 tanto para x como para y. Por eso, en lugar de utilizar la función of.random(-1, 1) se usa  of.randomf(), sin parámetros, porque son esos los que tiene establecidos por defecto.

--	
----------------------------------------------------------
--	Mosaic | OF Visual Patching Developer Platform
--
--	Copyright (c) 2018 Emanuele Mazza aka n3m3da
--
--	Mosaic is distributed under the MIT License. This gives everyone the
--    freedoms to use Mosaic in any context: commercial or non-commercial,
--    public or private, open or closed source.
--
--    See https://github.com/d3cod3/Mosaic for documentation
--  ----------------------------------------------------------         E-4-18
--     Random Walker tradicional
--
mouseX = 0
mouseY = 0
-----------
x0 = 1280/2   -- poner tamaño ventana salida 1280 x 720
y0 = 720/2
step = 4
pinta_fondo = true

----------------------------------------------------
function setup()

end
----------------------------------------------------
function update()

end
----------------------------------------------------

function draw()
   if pinta_fondo then
      -- draw background first 
      mosaicBackground(0,0,0,255) -- fondo negro solo lo pinta una vez
      pinta_fondo = false
    end

    of.setColor(255)
    xsig = x0 + (step * of.randomf())
    ysig = y0 + (step * of.randomf())

    of.drawLine(x0, y0, xsig, ysig)
    x0 = xsig           -- el valor de las dos últimas coordenadas de la línea
    y0 = ysig           -- pasa a las primeras para unir las líneas en recorrido
end

Este caminante recorre 4 px en cada paso, lo que transforma la opción de puntos en pequeñas líneas encadenadas. El segundo par de coordenadas de cada línea (xsig, ysig) será el primero de la siguiente, trazando así el recorrido de su deriva. Como el rectángulo que hemos utilizado habitualmente como fondo se dibuja de nuevo en cada frame, para visualizar el recorrido no hay que ponerlo.

En esta opción tradicional existe 1/8 = 12,5% de probabilidades de que el punto se traslade a una las 8 posiciones posibles cada vez que se efectúa el random, indistintamente de cuantas veces lo haga.

Daniel Shiffman (2012, 9) plantea un Random Walker que tiende a moverse hacia una dirección porque, como mencionaba la definición de este algoritmo, su planteamiento sirve para representar trayectorias, especialmente en medios fluidos, como el vuelo de las aves, o el movimiento en líquidos, donde la rigidez de la geometría euclidiana queda relegada por lo fluido.

Estas trayectorias orgánicas no están totalmente abiertas sino que marcan una tendencia de dirección. Shiffman regula esta dirección de trayectoria por medio de porcentajes, con un Random Walker que tiende a la derecha según las siguientes probabilidades: Moverse hacia arriba 20%, abajo 20%, izquierda 20%, derecha 40%.  Quedando el código de programación sujeto a condicionales if de modo que, sin hacer nunca el mismo camino, siempre que activemos el programa, el recorrido va a la derecha.

--
--   ----------------------------------------------------------
--   Mosaic | OF Visual Patching Developer Platform
--
--   Copyright (c) 2018 Emanuele Mazza aka n3m3da
--
--   Mosaic is distributed under the MIT License. This gives everyone the
--   freedoms to use Mosaic in any context: commercial or non-commercial,
--   public or private, open or closed source.
--
--   See https://github.com/d3cod3/Mosaic for documentation
--   ----------------------------------------------------------  E-4-19
--   Random Walker condicionado
--
mouseX = 0
mouseY = 0
--------------
x0 = 1280/2      -- poner tamaño ventana salida 1280 x 720
y0 = 720/2
step = 4
xsig = x0-step
ysig = y0-step
----------------------------------------------------
function setup()

end
----------------------------------------------------

function update()
  x0 = xsig
  y0 = ysig
end
----------------------------------------------------
                                                        
function draw()
  if pinta_fondo then 
     -- draw background first 
     mosaicBackground(0,0,0,255) -- fondo negro solo lo pinta una vez 
     pinta_fondo = false 
  end

  of.setColor(255)
  r = of.random(1)               -- si solo hay un parámetro el random es entre 0 y ese valor
  if  r < 0.4 then	         -- condición 40% de probabilidad hacia derecha
    xsig = x0 + step
  elseif r < 0.6 then            -- no es 60%, elseif solo actúa si no cabe en if
    xsig = x0 - step
  elseif r < 0.8 then
    ysig = y0 + step
  else
    ysig = y0 - step
  end
  of.drawLine(x0, y0, xsig, ysig)
end

Noise

Con la función of.random() se pueden generar series de valores inesperados, con una distribución uniforme, no uniforme o personalizada, pero son valores que no guardan relación entre sí. La función of.noise() genera también valores inesperados pero de una forma más controlable. Su nombre proviene de la función matemática Noise Perlin desarrollada por Ken Perlin para generar las texturas de la película Tron.

El Ruido Perlin es una función matemática que utiliza interpolación entre un gran número de gradientes precalculados de vectores que construyen un valor que varía pseudo-aleatoriamente en el espacio o tiempo. Se parece al ruido blanco. (Wikipedia, Ruido Perlin)

La función of.noise() puede tener de 1 a cuatro parámetros para calcular valores  Noise Perlin de una a cuatro dimensiones, expresado en valores entre 0.0 y 1.0. Por ejemplo of.noise(float x, float y) puede crear una textura bidimensional, y con 4 parámetros of.noise(float x, float y, float z, float w) calcula el valor de Noise Perlin de cuatro dimensiones entre 0.0 … 1.0.  Los siguientes ejemplos muestran el uso de noise para una y dos dimensiones.

--
--    ----------------------------------------------------------
--    Mosaic | OF Visual Patching Developer Platform
--
--    Copyright (c) 2018 Emanuele Mazza aka n3m3da
--
--    Mosaic is distributed under the MIT License. This gives everyone the
--    freedoms to use Mosaic in any context: commercial or non-commercial,
--    public or private, open or closed source.
--
--    See https://github.com/d3cod3/Mosaic for documentation
--    ---------------------------------------------------------- E-4-20
-- 
--    Basics/noise_map
--    Modulación Noise 1D
--

mouseX = 0
mouseY = 0
----------
v = 0.0	
inc = 0.01

----------------------------------------------------
function setup()

end
----------------------------------------------------
function update()

  v = v + inc    	-- el valor de noise se incrementa cada frame	
end

----------------------------------------------------
function draw()	
   -- draw background first 
   mosaicBackground(255,255,255,255)     -- fondo blanco sin transparencia
   of.setColor(0).       
                                         -- x depende del valor de noise mapeado			
  x = of.map(of.noise(v),0.2,0.8,0,OUTPUT_WIDTH, false)
  y = OUTPUT_HEIGHT/2 + of.random(-4, 4) -- y depende de un random
  of.drawCircle(x, y, 16, 16)
end

La función of.noise() no genera realmente números más relacionados ente sí que la función of.random(), funciona de manera diferente. El rango de los datos de salida es fijo, siempre el mismo valor. Por eso, el cálculo se realiza sobre una variable que va incrementando su valor paso a paso en el bloque update(), generando una imagen en movimiento que serpentea ondulatoriamente de forma continua e irregular. La oscilación en el eje Y se realiza con un random, pero también puede hacerse con un noise 2D

--
--    ----------------------------------------------------------
--    Mosaic | OF Visual Patching Developer Platform
--
--    Copyright (c) 2018 Emanuele Mazza aka n3m3da
--
--    Mosaic is distributed under the MIT License. This gives everyone the
--    freedoms to use Mosaic in any context: commercial or non-commercial,
--    public or private, open or closed source.
--
--    See https://github.com/d3cod3/Mosaic for documentation
--    ----------------------------------------------------------  E-4-21
--
--    Modulación Noise 2D 
--    origen: Noise Wave de Daniel Shiffman
--    processing.org/ejemplos/noisewave.html
--

mouseX = 0
mouseY = 0
-------------
yoff = 0.0        -- Perlin noise 2D	
xoff = 0.0

----------------------------------------------------
function setup()

end

----------------------------------------------------
function update()
  yoff = yoff + 0.01    -- incremento valor de noise
end
----------------------------------------------------
  
function draw()
  -- draw background first 
  mosaicBackground(0,0,0,255)       -- fondo negro
  of.setColor(255)
  of.beginShape()                   -- inicio forma irregular 	
      xoff = 0.0
      for x = 0, OUTPUT_WIDTH, 10 do    -- para y, se mapean los valores de noise
          y = of.map(of.noise(xoff, yoff), 0, 1, 300,350) -- 2D noise
         of.vertex(x, y)                -- primer punto del vertex
         xoff = xoff + 0.05             -- incrementa valor x para noise dentro del for
       end
      of.vertex(OUTPUT_WIDTH, OUTPUT_HEIGHT)
      of.vertex(0, OUTPUT_HEIGHT)
  of.endShape(true)                     -- cierra la forma
end