Lo scopo della sfida è di tracciare approssimativamente l' attrattore della mappa logistica in funzione del suo parametro r (chiamato anche diagramma di biforcazione ) o di una sua sottoregione. L'aspetto del grafico può essere visto nella seguente immagine da Wikipedia:

sfondo

La mappa logistica è una funzione matematica che accetta un input x _k e lo mappa su un output x _{k + 1} definito come

             x _{k + 1} = r x _k (1− x _k )

dove r è il parametro della mappa, si presume si trovi nell'intervallo [0, 4].

Dato r in [0,4], e un valore iniziale x ₀ nell'intervallo [0,1], è interessante applicare ripetutamente la funzione per un numero grande N di iterazioni, producendo un valore finale x _N . Nota che x _{N si} troverà necessariamente anche in [0,1].

Ad esempio, considera r = 3.2, N = 1000. Il valore iniziale x ₀ = 0,01 indica x ₁₀₀₀ = 0,5130. Per x ₀ = 0,02 il risultato è x ₀ = 0,7995. Per qualsiasi altro valore iniziale x _0, i valori finali x ₁₀₀₀ sono estremamente vicini a 0,5130 o 0,7995. Questo è visto nel grafico come l'altezza delle due linee in posizione orizzontale r = 3.2.

Ciò non significa che per r = 3.2 ogni sequenza converge in uno di quei due valori. In effetti, per i due valori iniziali considerati sopra, le sequenze sono (notare il comportamento oscillante):

             x ₀ = 0,01, ..., x ₁₀₀₀ = 0,5130, x ₁₀₀₁ = 0,7995, x ₁₀₀₂ = 0,5130, ...
             x ₀ = 0,02, ..., x ₁₀₀₀ = 0,7995, x ₁₀₀₁ = 0,5130, x ₁₀₀₂ = 0,7995 , ...

Ciò che è vero è che per N sufficientemente grande , e per quasi tutti i valori iniziali x ₀ , il termine x _N sarà vicino a uno degli elementi dell'insieme {0,5130, 0,7995}. Questo set è chiamato attrattore per questo specifico r .

Per altri valori del parametro r, le dimensioni del set di attrattori o dei suoi elementi cambieranno. Il grafico traccia gli elementi nell'attrattore per ogni r .

L'attrattore per una specifica r può essere stimato da

1. test di una vasta gamma di valori iniziali x ₀ ;
2. lasciando evolvere il sistema per un grande numero N di iterazioni; e
3. prendendo nota dei valori finali x _N ottenuti.

La sfida

ingressi

• N : numero di iterazioni.

• r ₁ , r ₂ e s . Definiscono l'insieme R dei valori di r , ovvero R = { r ₁ , r ₁ + s , r ₁ + 2 s , ..., r ₂ }.

Procedura

L'insieme X dei valori iniziali x ₀ è fisso: X = {0,01, 0,02, ..., 0,99}. Opzionalmente, 0 e 1 possono anche essere inclusi in X .

Per ogni r in R e ogni x ₀ in X , iterarlo logistici mappa N volte per produrre x _N . Registra le tuple ottenute ( r , x _N ).

Produzione

Traccia ogni tupla ( r , x _N ) come punto nel piano con r come asse orizzontale e x _N come asse verticale. L'output deve essere grafico (non arte ASCII).

Regole aggiuntive

• La procedura indicata definisce il risultato richiesto, ma non viene applicata. È possibile utilizzare qualsiasi altra procedura che proclami la stessa serie di tuple ( r , x _N ).
• L'input è flessibile come al solito.
• Gli errori in virgola mobile non verranno mantenuti contro il risponditore.
• È richiesto un output grafico, in uno qualsiasi dei formati accettati . In particolare, l'output può essere visualizzato sullo schermo, oppure può essere prodotto un file grafico o può essere emesso un array di valori RGB. Se si genera un file o un array, si prega di pubblicare un esempio di come appare quando viene visualizzato.
• La grafica può essere vettoriale o raster. Per la grafica raster, la dimensione dell'immagine dovrebbe essere di almeno 400 × 400 pixel.
• Ogni punto dovrebbe essere mostrato come un singolo pixel o come un segno con le dimensioni dell'ordine di un pixel (altrimenti il ​​grafico si ingombra rapidamente).
• L'intervallo degli assi deve essere [0,4] per r (asse orizzontale) e [0,1] per x _N (asse verticale); oppure può essere più piccolo purché includa tutti i punti ottenuti.
• Le scale degli assi sono arbitrarie. In particolare, la scala non deve essere la stessa per entrambi gli assi.
• Le linee della griglia, le etichette degli assi, i colori e gli elementi simili sono accettabili, ma non richiesti.
• Vince il codice più breve in byte.

Casi test

Fare clic su ciascuna immagine per una versione ad alta risoluzione.

N = 1000; r1 = 2.4; r2 = 4; s = 0.001;

N = 2000; r1 = 3.4; r2 = 3.8; s = 0.0002;

N = 10000; r1 = 3.56; r2 = 3.59; s = 0.00002;

Riconoscimento

Grazie a @FryAmTheEggman e @AndrasDeak per i loro utili commenti mentre la sfida era nella sandbox.

MATL, 32 30 28 27 byte

4 byte salvati grazie a @Luis

3$:0:.01:1!i:"tU-y*]'.'3$XG

Il formato di input è r1, s, r2, eN

Provalo su MATL Online

Spiegazione

        % Implicitly grab the first three inputs
3$:     % Take these three inputs and create the array [r1, r1+s, ...]
0:.01:1 % [0, 0.01, 0.02, ... 1]
!       % Transpose this array
i       % Implicitly grab the input, N
:"      % For each iteration
  tU    % Duplicate and square the X matrix
  -     % Subtract from the X matrix (X - X^2) == x * (1 - x)
  y     % Make a copy of R array
  *     % Multiply the R array by the (X - X^2) matrix to yield the new X matrix
]       % End of for loop
'.'    % Push the string literal '.' to the stack (specifies that we want
        % dots as markers)
3$XG    % Call the 3-input version of PLOT to create the dot plot

Mathematica, 65 byte

Graphics@Table[Point@{r,Nest[r#(1-#)&,x,#]},{x,0,1,.01},{r,##2}]&

Funzione pura che accetta gli argomenti N, r1, r2, s in quell'ordine. Nest[r#(1-#)&,x,N]itera la funzione logistica per r#(1-#)&un totale di Nvolte a partire da x; qui il primo argomento della funzione ( #) è quello Nin questione; Point@{r,...}produce un Pointche Graphicssarà felice di tramare. Table[...,{x,0,1,.01},{r,##2}]crea un sacco di questi punti, con il xvalore che va da 0a 1con incrementi di .01; in ##2in {r,##2}indica tutti gli argomenti della funzione originale a partire dalla seconda e quindi si {r,##2}espande a {r,r1,r2,s}cui imposta correttamente l'intervallo e l'incremento r.

Esempio di output, nel secondo caso di test: l'input

Graphics@Table[Point@{r,Nest[r#(1-#)&,x,#]},{x,0,1,.01},{r,##2}]&[2000,3.4,3.8,0.0002]

produce la grafica qui sotto.

Mathematica, 65 byte

Ho usato alcuni dei trucchi di Greg Martin e questa è la mia versione senza usare la grafica

ListPlot@Table[{r,NestList[#(1-#)r&,.5,#][[-i]]},{i,99},{r,##2}]&

ingresso

[1000, 2.4, 4, 0.001]

produzione

ingresso

[2000, 3.4, 3.8, 0.0002]

produzione

TI-Basic, 85 byte

Prompt P,Q,S,N
P→Xmin:Q→Xmax
0→Ymin:1→Ymax
For(W,.01,1,.01
For(R,P,Q,S
W→X
For(U,1,N
R*X*(1-X→X
End
Pt-On(R,X
End
End

Un programma TI-Basic completo che accetta input nell'ordine r1,r2,s,Ne quindi mostra l'output in tempo reale sullo schermo del grafico. Si noti che questo tende ad essere incredibilmente lento .

Ecco un output di esempio incompleto generato dopo circa 2,5 ore per l'input 3,4,0.01,100:

Elaborazione JS, 125 123 120 byte

Grazie a Lithos Kritixi per aver salvato 3 byte.

var f(n,q,r,s){size(4e3,1e3);for(i=0;i<1;i+=.01)for(p=q;p<=r;p+=s){x=i;for(j=0;j<n;j++)x*=p-p*x;point(p*1e3,1e3-x*1e3)}}

Provalo online! Chiama usandof(N, r_1, r_2, s);

GEL , 158 byte

`(N,r,t,s)=(LinePlotWindow=[r,t,0,1];for i=r to t by s do(p=.;for w=0to 1by 0.01do(x=w;for a=0to N do(x=i*x*(1-x););p=[p;q=[i,x]];);LinePlotDrawPoints(p);););

Potrebbe non essere il più breve, ma disegna in tempo reale, anche se può essere incredibilmente lento con enormi input. Comunque, questa è una funzione anonima che accetta input nel formato (N,r1,r2,s)e genera la trama in una nuova finestra. Nota che questo deve essere eseguito con la versione GNOME di Genius.

R, 159 147 byte

pryr::f({plot(NA,xlim=c(a,b),ylim=0:1);q=function(r,n,x=1:99/100){for(i in 1:n)x=r*x*(1-x);x};for(i in seq(a,b,s))points(rep(i,99),q(i,n),cex=.1)})

Quale produce la funzione

function (a, b, n, s) 
{
    plot(NA, xlim = c(a, b), ylim = 0:1)
    q = function(r, n, x = 1:99/100) {
        for (i in 1:n) x = r * x * (1 - x)
        x
    }
    for (i in seq(a, b, s)) points(rep(i, 99), q(i, n), cex = 0.1)
}

plot(NA,...)crea una tela vuota che ha le dimensioni corrette. qè la funzione che esegue l'iterazione. Prende un valore di r, quindi esegue niterazioni per tutti i punti di partenza tra 0.01e 0.99. Quindi restituisce il vettore risultante.

Il for-loop applica la funzione qalla sequenzaa di bcon passo s. Invece di restituire i valori, li aggiunge come punti alla trama. Se il punto di attrazione ha un valore, tutti i punti si sovrappongono e si mostrano come un punto. cex=.1è un'aggiunta necessaria per rendere i punti più piccoli possibili.