Calcolo dell'insieme di Mandelbrot

    let passiMassimi = 100;
let palette = [];

function setup() {
    createCanvas( 560, 400 );
    for (let n = 0;  n < passiMassimi;  n++) {
        let t = n / 30;
        palette[n] = [ onda( t, 1, 0 ), onda( t, 1, 0.1 ),
                       onda( t, 1, 0.2 ), 255 ];
    }
    palette[passiMassimi] = [ 0, 0, 0, 255 ];

    for (let py = 0;  py < height;  py++) {
        for (let px = 0;  px < width;  px++) {
            let cx = map( px, 0, width, -2.5, 1 );
            let cy = map( py, 0, height, -1.25, 1.25 );
            let x = 0;
            let y = 0;
            let passi = 0;
            while (passi < passiMassimi && x*x + y*y < 4) {
                let xSuccessivo = x*x - y*y + cx;
                y = 2*x*y + cy;
                x = xSuccessivo;
                passi++;
            }
            set( px, py, palette[passi] );
        }
    }
    updatePixels();
}

function onda( t, frequenza, fase ) {
    return cos( TWO_PI * (frequenza * t + fase) ) * 127.5 + 127.5;
}
  

  let cx = map( px, 0, width, -2.5, 1 );
let cy = map( py, 0, height, -1.25, 1.25 );

Ogni pixel corrisponde a un punto del piano, di coordinate cx e cy: la tela mostra la zona fra -2.5 e 1 in orizzontale e fra -1.25 e 1.25 in verticale.

  let xSuccessivo = x*x - y*y + cx;
y = 2*x*y + cy;
x = xSuccessivo;

La regola che trasforma il punto x, y nel punto successivo, sempre la stessa: il calcolo parte da 0, 0, e ogni passo usa il risultato del passo precedente. xSuccessivo conserva il nuovo valore di x finché non è stato calcolato anche quello di y, che usa il vecchio.

  while (passi < passiMassimi && x*x + y*y < 4) {

Il calcolo si ripete finché il punto resta a una distanza minore di 2 dall’origine, per al massimo 100 passi. Si confronta il quadrato della distanza con 4, per non calcolare la radice quadrata.

  set( px, py, palette[passi] );

Il numero di passi compiuti diventa l’indice della palette, calcolata con le oscillazioni dei tre canali. I punti che dopo 100 passi non si sono allontanati appartengono all’insieme, e prendono l’ultimo colore, il nero.

Ingrandendo il filamento a sinistra, da -1.8 a -1.7 in orizzontale e da -0.0357 a 0.0357 in verticale, con passiMassimi = 300, compare una copia ridotta dell’insieme.

Con t = n / 10 le bande di colore diventano più strette, e cambiando le fasi della palette cambiano i colori.

La regola è il quadrato di un numero complesso a cui si somma il numero complesso del pixel, scritta con le due coordinate separate. I colori della palette sono array di quattro valori, rosso, verde, blu e opacità, che set() usa molto più rapidamente dei colori creati con color(). Per lo stesso motivo i pixel si calcolano riga per riga, con py nel ciclo esterno.