Qual è l'origine di questa riga GLSL rand ()?

Ho visto questo generatore di numeri pseudo-casuali da utilizzare negli shader a cui si fa riferimento qua e là in giro per il web :

float rand(vec2 co){
  return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
}

È variamente chiamato "canonico", o "una battuta che ho trovato da qualche parte sul web".

Qual è l'origine di questa funzione? I valori costanti sono così arbitrari come sembrano o c'è qualche arte nella loro selezione? C'è qualche discussione sui meriti di questa funzione?

EDIT: Il riferimento più antico a questa funzione che ho incontrato è questo archivio del febbraio '08 , la pagina originale ora scomparsa dal web. Ma non se ne discute più che altrove.

Domanda molto interessante!

Sto cercando di capirlo mentre digito la risposta :) Prima un modo semplice per giocarci: http://www.wolframalpha.com/input/?i=plot%28+mod%28+sin%28x*12.9898 +% 2B + y * 78,233% 29 + * + 43758,5453% 2C1% 29x% 3D0..2% 2C + y% 3D0..2% 29

Quindi pensiamo a quello che stiamo cercando di fare qui: per due coordinate di input x, y restituiamo un "numero casuale". Tuttavia, questo non è un numero casuale. È lo stesso ogni volta che inseriamo la stessa x, y. È una funzione hash!

La prima cosa che fa la funzione è passare da 2d a 1d. Questo non è interessante di per sé, ma i numeri sono scelti in modo che non si ripetano normalmente. Inoltre abbiamo un'aggiunta in virgola mobile lì. Ci saranno ancora alcuni bit da y o x, ma i numeri potrebbero essere scelti correttamente in modo da fare un mix.

Quindi campioniamo una funzione sin () della scatola nera. Questo dipenderà molto dall'implementazione!

Infine amplifica l'errore nell'implementazione di sin () moltiplicando e prendendo la frazione.

Non penso che questa sia una buona funzione hash nel caso generale. Il sin () è una scatola nera, sulla GPU, numericamente. Dovrebbe essere possibile costruirne uno molto migliore prendendo quasi tutte le funzioni hash e convertendole. La parte difficile è trasformare la tipica operazione intera usata nell'hashing della CPU in operazioni float (metà o 32 bit) o ​​in virgola fissa, ma dovrebbe essere possibile.

Ancora una volta, il vero problema con questa funzione hash è che sin () è una scatola nera.

L'origine è probabilmente l'articolo: "Sulla generazione di numeri casuali, con l'aiuto di y = [(a + x) sin (bx)] mod 1", WJJ Rey, 22nd European Meeting of Statisticians and the 7th Vilnius Conference on Probability Theory and Statistica matematica, agosto 1998

EDIT: Dal momento che non riesco a trovare una copia di questo documento e il riferimento "TestU01" potrebbe non essere chiaro, ecco lo schema descritto in TestU01 in pseudo-C:

#define A1 ???
#define A2 ???
#define B1 pi*(sqrt(5.0)-1)/2
#define B2 ???

uint32_t n;   // position in the stream

double next() {
  double t = fract(A1     * sin(B1*n));
  double u = fract((A2+t) * sin(B2*t));
  n++;
  return u;
} 

dove l'unico valore di costante consigliato è B1.

Notare che questo è per un flusso. La conversione in un hash 1D 'n' diventa la griglia intera. Quindi la mia ipotesi è che qualcuno abbia visto questo e abbia convertito 't' in una semplice funzione f (x, y). Utilizzando le costanti originali di cui sopra che produrrebbe:

float hash(vec2 co){
  float t = 12.9898*co.x + 78.233*co.y; 
  return fract((A2+t) * sin(t));  // any B2 is folded into 't' computation
}

i valori costanti sono arbitrari, soprattutto perché sono molto grandi e distano un paio di decimali dai numeri primi.

un modulo superiore a 1 di un seno di ampiezza elevata moltiplicato per 4000 è una funzione periodica. è come una tenda da finestra o un metallo ondulato reso molto piccolo perché moltiplicato per 4000 e ruotato di un angolo dal prodotto punto.

poiché la funzione è 2-D, il prodotto scalare ha l'effetto di ruotare la funzione periodica obliqua rispetto agli assi X e Y. Con rapporto 13/79 circa. È inefficiente, puoi effettivamente ottenere lo stesso facendo sinus di (13x + 79y), questo otterrà anche la stessa cosa penso con meno matematica ..

Se trovi il periodo della funzione sia in X che in Y, puoi campionarlo in modo che assomigli di nuovo a una semplice onda sinusoidale.

Ecco un'immagine di esso ingrandita nel grafico

Non conosco l'origine ma è simile a molti altri, se lo usassi nella grafica a intervalli regolari tenderebbe a produrre moiré e potresti vedere che alla fine va di nuovo in giro.

Forse è una mappatura caotica non ricorrente, quindi potrebbe spiegare molte cose, ma può anche essere solo una manipolazione arbitraria con grandi numeri.

EDIT: Fondamentalmente, la funzione fract (sin (x) * 43758.5453) è una semplice funzione simile a un hash, il sin (x) fornisce un'interpolazione sin uniforme tra -1 e 1, quindi sin (x) * 43758.5453 sarà interpolazione da - 43758.5453 a 43758.5453. Questo è un intervallo abbastanza ampio, quindi anche un piccolo passo in x fornirà un grande passo nel risultato e una variazione davvero grande nella parte frazionaria. Il "fract" è necessario per ottenere valori nell'intervallo da -0,99 ... a 0,999 .... Ora, quando abbiamo qualcosa come la funzione hash, dovremmo creare una funzione per l'hash di produzione dal vettore. Il modo più semplice è chiamare "hash" separatamente per x qualsiasi componente y del vettore di input. Ma poi, avremo alcuni valori simmetrici. Quindi, dovremmo ottenere un valore dal vettore, l'approccio è trovare un vettore casuale e trovare il prodotto "punto" per quel vettore, qui andiamo: fract (sin (punto (co.xy, vec2 (12.9898,78.233))) * 43758.5453); Inoltre, in base al vettore selezionato, la sua lunghezza dovrebbe essere abbastanza lunga per avere diversi peroidi della funzione "sin" dopo che sarà calcolato il prodotto "punto".