Tujuan dari tantangannya adalah sekitar plot penarik dari peta logistik sebagai fungsi dari parameter yang r (juga disebut bifurkasi diagram ), atau sub regional itu. Tampilan grafik dapat dilihat pada gambar berikut dari Wikipedia:

Latar Belakang

The peta logistik adalah fungsi matematika yang mengambil input x _k dan peta untuk output x _{k + 1} didefinisikan sebagai

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

di mana r adalah parameter peta, diasumsikan terletak pada interval [0, 4].

Mengingat r di [0,4], dan nilai awal x ₀ pada interval [0,1], sangat menarik untuk berulang kali mengajukan permohonan fungsi untuk sejumlah besar N iterasi, menghasilkan nilai akhir x _N . Perhatikan bahwa x _{N juga} akan terletak pada [0,1] juga.

Sebagai contoh, pertimbangkan r = 3,2, N = 1000. Nilai awal x ₀ = 0,01 memberi x ₁₀₀₀ = 0,5130. Untuk x ₀ = 0,02 hasilnya adalah x ₀ = 0,7995. Untuk setiap nilai awal lainnya x ₀ nilai akhir x ₁₀₀₀ sangat dekat dengan baik 0,5130 atau 0,7995. Ini terlihat dalam grafik sebagai ketinggian dua garis pada posisi horisontal r = 3,2.

Ini tidak berarti bahwa untuk r = 3,2 setiap urutan konvergen ke salah satu dari dua nilai tersebut. Bahkan, untuk dua nilai awal yang dipertimbangkan di atas, urutannya adalah (perhatikan perilaku berosilasi):

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

Apa yang benar adalah bahwa untuk cukup besar N , dan untuk hampir semua nilai awal x ₀ , istilah x _N akan mendekati salah satu elemen dari himpunan {0,5130, 0,7995}. Set ini disebut sebagai penarik r khusus ini .

Untuk nilai lain dari parameter r ukuran atractor set, atau elemen-elemennya, akan berubah. Grafik memplot elemen dalam penarik untuk setiap r .

Penarik untuk r tertentu dapat diperkirakan oleh

1. menguji berbagai nilai awal x ₀ ;
2. membiarkan sistem berevolusi untuk sejumlah besar N iterasi; dan
3. mencatat nilai akhir x _N yang diperoleh.

Tantangan

Input

• N : jumlah iterasi.

• r ₁ , r ₂ dan s . Ini menentukan himpunan R dari nilai r , yaitu R = { r ₁ , r ₁ + s , r ₁ + 2 s , ..., r ₂ }.

Prosedur

Set X dari nilai awal x ₀ adalah tetap: X = {0,01, 0,02, ..., 0,99}. Opsional, 0 dan 1 juga dapat dimasukkan dalam X .

Untuk setiap r di R dan masing-masing x ₀ di X , iterate logistik peta N kali untuk menghasilkan x _N . Catat tupel yang diperoleh ( r , x _N ).

Keluaran

Plot setiap tupel ( r , x _N ) sebagai titik di bidang dengan r sebagai sumbu horizontal dan x _N sebagai sumbu vertikal. Keluaran harus berupa grafik (bukan seni ASCII).

Aturan tambahan

• Prosedur yang ditunjukkan menentukan hasil yang diperlukan, tetapi tidak ditegakkan. Prosedur lain apa pun yang menghasilkan set tupel ( r , x _N ) yang sama dapat digunakan.
• Input fleksibel seperti biasa.
• Kesalahan floating point tidak akan ditahan terhadap penjawab.
• Output grafis diperlukan, dalam format apa pun yang diterima . Secara khusus, output dapat ditampilkan di layar, atau file grafik dapat diproduksi, atau array nilai RGB mungkin output. Jika menghasilkan file atau array, silakan posting contoh seperti apa saat ditampilkan.
• Grafik dapat berupa vektor atau raster. Untuk grafik raster, ukuran gambar harus setidaknya 400 × 400 piksel.
• Setiap titik harus ditampilkan sebagai satu piksel, atau sebagai tanda dengan ukuran urutan satu piksel (jika tidak, grafik dengan cepat akan berantakan).
• Rentang sumbu harus [0,4] untuk r (sumbu horizontal) dan [0,1] untuk x _N (sumbu vertikal); atau mungkin lebih kecil asalkan mencakup semua poin yang diperoleh.
• Timbangan sumbu bersifat arbitrer. Secara khusus, skalanya tidak harus sama untuk kedua sumbu.
• Garis kisi, label sumbu, warna, dan elemen serupa dapat diterima, tetapi tidak diperlukan.
• Kode terpendek dalam byte menang.

Uji kasus

Klik pada setiap gambar untuk versi resolusi tinggi.

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;

Pengakuan

Terima kasih kepada @FryAmTheEggman dan @AndrasDeak atas komentar bermanfaat mereka sementara tantangannya ada di kotak pasir.

MATL, 32 30 28 27 byte

4 byte disimpan berkat @Luis

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

Format input r1, s, r2, danN

Cobalah di MATL Online

Penjelasan

        % 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}]&

Fungsi murni mengambil argumen N, r1, r2, s dalam urutan itu. Nest[r#(1-#)&,x,N]iterates fungsi logistik r#(1-#)&total Nkali mulai dari x; di sini argumen pertama ke function ( #) adalah Npertanyaan; Point@{r,...}menghasilkan Pointyang Graphicsakan senang untuk merencanakan. Table[...,{x,0,1,.01},{r,##2}]menciptakan sejumlah besar poin-poin ini, dengan xnilai berjalan dari 0ke 1dalam peningkatan .01; yang ##2di {r,##2}Menandakan semua argumen fungsi asli mulai dari yang kedua, dan begitu {r,##2}mengembang ke {r,r1,r2,s}yang benar menetapkan jangkauan dan peningkatan untuk r.

Contoh output, pada test case kedua: input

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

menghasilkan grafik di bawah ini.

Mathematica, 65 byte

Saya menggunakan beberapa trik Greg Martin dan ini adalah versi saya tanpa menggunakan Grafik

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

memasukkan

[1000, 2.4, 4, 0.001]

keluaran

memasukkan

[2000, 3.4, 3.8, 0.0002]

keluaran

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

Program TI-Basic lengkap yang mengambil input dalam urutan r1,r2,s,Ndan kemudian menampilkan output secara real time pada layar grafik. Perhatikan bahwa ini cenderung sangat lambat .

Berikut adalah contoh output tidak lengkap yang dihasilkan setelah sekitar 2,5 jam untuk input 3,4,0.01,100:

Memproses JS, 125 123 120 byte

Terima kasih kepada Kritixi Lithos untuk menghemat 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)}}

Cobalah online! Panggilan menggunakanf(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);););

Ini mungkin bukan yang terpendek, tetapi menarik secara real time, meskipun bisa sangat lambat dengan input besar. Bagaimanapun, ini adalah fungsi anonim yang mengambil input dalam format (N,r1,r2,s)dan output plot di jendela baru. Perhatikan bahwa ini harus dijalankan dengan Genius versi GNOME.

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)})

Yang menghasilkan fungsi

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,...)menciptakan kanvas kosong yang memiliki dimensi yang benar. qadalah fungsi yang melakukan iterasi. Dibutuhkan nilai r, dan kemudian melakukan niterasi untuk semua titik awal antara 0.01dan 0.99. Kemudian mengembalikan vektor yang dihasilkan.

Untuk loop berlaku fungsi quntuk urutan ake bdengan langkah s. Alih-alih mengembalikan nilai, itu menambahkan mereka sebagai poin ke plot. Jika titik tarikan adalah satu nilai, semua poin akan tumpang tindih dan ditampilkan sebagai satu titik. cex=.1adalah tambahan yang diperlukan untuk membuat poin sekecil mungkin.