---
title: "Números pseudo-aleatorios"
---

Processing incluye funciones para obtener números elegidos "al azar".

Técnicamente se dice que estos números son *pseudo-aleatorios* porque parten de un algoritmo específico que podría predecirse pero que simula azar. No parten de una operación realmente azarosa (como tirar un dado o lanzar una moneda).

Como sea, para fines prácticos, los podemos considerar *aleatorios*.

# Funciones

## random(  )

Genera y regresa un número pseudo-aleatorio de tipo `float`.

Con un argumento, `random( n )` regresa un número aleatorio entre 0 y `n`; incluye al 0 pero no a `n `. `n` es un número de tipo `float`:

```java
// la variable distancia tomará un valor entre 0 y 100
float distancia = random( 100 );
```

Con dos argumentos, `random( min, max )` regresa un número aleatorio entre `min` y `max`; incluye a `min` pero no a `max`. Ambos argumentos son de tipo `float`:

```java
// la variable "ancho" tomará un valor entre 100 y 200:
float ancho = random( 100, 200 );
```

### Números enteros

Para obtener un número entero (tipo `int`) aleatorio, hay que convertir el resultado de `random( )` con la función `int( )` que eliminará la parte decimal:

```java
// 'n' tomará uno de los siguientes valores:
// 0, 1, 2, 3, 4, 5, 6, 7, 9
int n = int( random( 10 ) );

// 'dado' tomará uno de los siguientes valores:
// 1, 2, 3, 4, 5, 6
int dado = int( random( 1, 7 ) );
```

## randomSeed( n )

Esta función establece la "semilla" `n` (tipo `int`) desde la cual se van a generar los números aleatorios que se obtengan a continuación. 

El usar esta función hace que los números aleatorios que obtengamos sean los mismos cada vez que ejecutemos el programa.

Podría parecer que eso no tiene sentido. Pero se utiliza para obtener y *poder repetir* resultados con parámetros azarosos.

### Ejemplo

En el siguiente ejemplo, cada vez que ejecutemos el programa el círculo estará en la misma posición. Nota que será una posición que no predefinimos. 

Si cambiamos el valor de la "semilla", el círculo aparecerá en otra posición, pero siempre en la misma.

Si comentamos/quitamos la función de `randomSeed( )`, cada vez que ejecutemos el programa el círculo estará en una nueva posición.

```java
size(200, 200);

// establece semilla aleatoria
randomSeed( 42 );

float x = random(200);
float y = random(200);

// el círculo estará en una posición aleatoria,
// pero siempre en la misma:
ellipse( x, y, 10, 10);
```

En ocasiones querremos el comportamiento con `randomSeed( )`, y en otras no :)

# Ejemplos

Colección de ejemplos comunes de cantidades obtenidas aleatoriamente

## Posición x,y 

### En todo el lienzo/canvas

```java
float x = random( width );
float y = random( height );
```

### En un área específica del lienzo/canvas

Obtén una posición aleatoria dentro de un cuadrado de 100x100, con esquina superior izquierda en `(100, 100)`:

```java
float minX = 100;
float maxX = 200;
float minY = 100;
float maxY = 200;

float x = random( minX, maxX );
float y = random( minY, maxY );
```

## Tamaño

Obtén una dimensión entre 200 y 300 pixeles:

```java
float tam = random( 200, 300); 
```

## Color

Podemos obtener colores aleatorios con la función `color( )`, donde uno o más de sus parámetros sean aleatorios.

Aquí se ejemplifican algunas posibilidades

### RGB

```java
// obtén un valor entre 0 y 255 en escala de grises
color gris = color( random(255) );

// obtén un color RGB aleatorio
color rgbAleatorio = color( random(255), random(255), random(255) );

// obtén un color RGBA aleatorio
color rgbaAleatorio = color( random(255), random(255), random(255), random(255) );

// colores con transparencia aleatoria:
color grisTransparente = color( 100, random(255) );
color rojoTransparente = color( 255, 0, 0, random(255) );
```

### HSB

```java
// cambia a modo de color HSB 
colorMode( HSB, 360, 100, 100, 100);

// obtén un color HSB aleatorio
color hsbAleatorio = color( random(360), random(100), random(100) );

// obtén un "hue" aleatorio, con saturación y brillo definidos:
color hueAleatorio = color( random(360), 80, 100 );
```
