Mandelbrot set: Difference between revisions

!!!!!!!!!!!!!!!""""""""""""#####################################""""""""""""""""

</pre>

 

=={{header|BASIC}}==

180 GOTO 180

</syntaxhighlight>

 

==={{header|Nascom BASIC}}===

Pt-On(real(C),imag(C),N

End

 

==={{header|Visual BASIC for Applications on Excel}}===

{{works with|Excel 2013}}

Based on the BBC BASIC version. Create a spreadsheet with -2 to 2 in row 1 and -2 to 2 in the A column (in steps of your choosing). In the cell B2, call the function with =mandel(B$1,$A2) and copy the cell to all others in the range. Conditionally format the cells to make the colours pleasing (eg based on values, 3-color scale, min value 2 [colour red], midpoint number 10 [green] and highest value black. Then format the cells with the custom type "";"";"" to remove the numbers.

 

maxiter = 256

mandel = i

[[File:vbamandel.png]]

Edit: I don't seem to be able to upload the screenshot, so I've shared it here: https://goo.gl/photos/LkezpuQziJPAtdnd9

 

=={{header|Craft Basic}}==

define py = 0, px = 0, sx = 0, sy = 0

define xx = 0, xy = 0

 

bgcolor 0, 0, 0

fill on

 

let py = py + 4

 

 

=={{header|D}}==

=={{header|Dc}}==

===ASCII output===

 

This can be done in a more Dc-ish way, e.g. by moving the loop macros' definitions to the initialisations in the top instead of saving the macro definition of inner loops over and over again in outer loops.

=={{header|EasyLang}}==

 

 

<syntaxhighlight lang="easylang">

y = 2 * x * y + cy

.

</syntaxhighlight>

 

=={{header|Fōrmulæ}}==

 

 

 

 

=={{header|GLSL}}==

 

[[File:Mandelbrot-Inform7.png]]

 

=={{header|J}}==

 

===Normal Map Effect, Mercator Projection and Perturbation Theory===

<syntaxhighlight lang="julia">using Plots

gr(aspect_ratio=:equal, axis=true, ticks=true, legend=false, dpi=200)

d, h = 800, 500 # pixel density (= image width) and image height

n, r = 200, 500 # number of iterations and escape radius (r > 2)

 

x = range(0, 2, length=d+1)

 

A, B = collect(x) .- 1, collect(y) .- h / d

 

 

for k in 1:n

end

 

N = abs.(Z) .> 2 # exterior distance estimation

 

heatmap(D .^ 0.1, c=:balance)

 

 

savefig("Mandelbrot_normal_map_1.png")

 

 

savefig("Mandelbrot_normal_map_2.png")</syntaxhighlight>

 

<syntaxhighlight lang="julia">using Plots

gr(aspect_ratio=:equal, axis=true, ticks=true, legend=false, dpi=200)

 

d, h = 200, 1200 # pixel density (= image width) and image height

 

x = range(0, 2, length=d+1)

 

A, B = collect(x) .* pi, collect(y) .* pi

 

Z, dZ = zero(C), zero(C)

D = zeros(size(C))

 

for k in 1:n

M = abs2.(Z) .< abs2(r)

end

 

D[N] = log.(abs.(Z[N])) .* abs.(Z[N]) ./ abs.(dZ[N])

 

savefig("Mercator_Mandelbrot_map.png")

 

 

gr(c=:nipy_spectral, axis=true, ticks=true, legend=false, markerstrokewidth=0)

plot(p1, p2, p3, p4, layout=(2, 2))

savefig("Mercator_Mandelbrot_zoom.png")</syntaxhighlight>

 

For deep zoom images it is sufficient to calculate a single point with high accuracy. A good approximation can then be found for all other points by means of a perturbation calculation with standard accuracy. Rebasing is used to reduce glitches. See [https://fractalforums.org/fractal-mathematics-and-new-theories/28/another-solution-to-perturbation-glitches/4360 Another solution to perturbation glitches] (Fractalforums) for details. See also the image [https://www.flickr.com/photos/arenamontanus/3430921497/in/album-72157615740829949/ Deeper Mercator Mandelbrot] by Anders Sandberg.

let c = a + b * im, z = zero(c)

for k in 1:n+1

if abs2(z) < abs2(r)

z = z ^ 2 + c

else

break

end

 

A, B = collect(x) .* pi, collect(y) .* pi

 

E, Z, dZ = zero(C), zero(C), zero(C)

D, I, J = zeros(size(C)), ones(Int64, size(C)), ones(Int64, size(C))

 

for k in 1:n

M, R = abs2.(Z) .< abs2(r), abs2.(Z) .< abs2.(E)

E[R], I[R] = Z[R], J[R] # rebase when z is closer to zero

Z[M], dZ[M] = S[I[M]] .+ E[M], 2 .* Z[M] .* dZ[M] .+ 1

end

Sample usage:

<syntaxhighlight lang="matlab">mandelbrotSet(-2.05-1.2i,0.004+0.0004i,0.45+1.2i,500);</syntaxhighlight>

 

=={{header|Metapost}}==

 

===Normal Map Effect, Mercator Projection and Deep Zoom Images===

<syntaxhighlight lang="python">import numpy as np

import matplotlib.pyplot as plt

d, h = 800, 500 # pixel density (= image width) and image height

n, r = 200, 500 # number of iterations and escape radius (r > 2)

 

x = np.linspace(0, 2, num=d+1)

 

A, B = np.meshgrid(x - 1, y - h / d)

 

 

for k in range(n):

 

N = abs(Z) > 2 # exterior distance estimation

 

plt.imshow(D ** 0.1, cmap=plt.cm.twilight_shifted, origin="lower")

 

 

plt.savefig("Mandelbrot_normal_map_1.png", dpi=200)

 

 

plt.savefig("Mandelbrot_normal_map_2.png", dpi=200)</syntaxhighlight>

 

<syntaxhighlight lang="python">import numpy as np

import matplotlib.pyplot as plt

 

d, h = 200, 1200 # pixel density (= image width) and image height

 

x = np.linspace(0, 2, num=d+1)

 

A, B = np.meshgrid(x * np.pi, y * np.pi)

 

Z, dZ = np.zeros_like(C), np.zeros_like(C)

for k in range(n):

M = Z.real ** 2 + Z.imag ** 2 < r ** 2

 

N = abs(Z) > 2 # exterior distance estimation

D[N] = np.log(abs(Z[N])) * abs(Z[N]) / abs(dZ[N])

 

plt.savefig("Mercator_Mandelbrot_map.png", dpi=200)

 

 

fig, ax = plt.subplots(2, 2, figsize=(12, 12))

plt.savefig("Mercator_Mandelbrot_zoom.png", dpi=100)</syntaxhighlight>

 

For deep zoom images it is sufficient to calculate a single point with high accuracy. A good approximation can then be found for all other points by means of a perturbation calculation with standard accuracy. Rebasing is used to reduce glitches. See [https://en.wikipedia.org/wiki/Plotting_algorithms_for_the_Mandelbrot_set#Perturbation_theory_and_series_approximation Perturbation theory] (Wikipedia) and [https://gbillotey.github.io/Fractalshades-doc/math.html#avoiding-loss-of-precision Avoiding loss of precision] (Fractalshades) for details. See also the image [https://www.flickr.com/photos/arenamontanus/3430921497/in/album-72157615740829949/ Deeper Mercator Mandelbrot] by Anders Sandberg.

 

for k in range(n+1):

if u ** 2 + v ** 2 < r ** 2:

u, v = u ** 2 - v ** 2 + a, 2 * u * v + b

else:

break

 

 

A, B = np.meshgrid(x * np.pi, y * np.pi)

 

E, Z, dZ = np.zeros_like(C), np.zeros_like(C), np.zeros_like(C)

M, R = Z2 < r ** 2, Z2 < E.real ** 2 + E.imag ** 2

E[R], I[R] = Z[R], J[R] # rebase when z is closer to zero

Z[M], dZ[M] = S[I[M]] + E[M], 2 * Z[M] * dZ[M] + 1

 

=={{header|Raku}}==

(formerly Perl 6)

 

$r.min, * + ($r.max - $r.min) / ($n - 1) ... $r.max

}

}

return 0;

}

 

Alternately, a more modern, faster version.

[[File:Mandelbrot-set-perl6.png|300px|thumb|right]]

 

my ($w, $h) = 800, 800;

}

}</syntaxhighlight>

 

=={{header|REXX}}==

# for which the sequence z[n+1] := z[n] ** 2 + z[0] (n >= 0) is bounded.

# Since this program is computing intensive it should be compiled with

 

const integer: pix is 200;

z0 := center + complex(flt(x) * zoom, flt(y) * zoom);

point(x + pix, y + pix, colorTable[iterate(z0)]);

end for;

end func;

end for;

displayMandelbrotSet(complex(-0.75, 0.0), 1.3 / flt(pix));

readln(KEYBOARD);

end func;

:End

</syntaxhighlight>

 

=={{header|TXR}}==

=={{header|UNIX Shell}}==

{{works with|Bourne Again SHell|4}}

 

 

 

 

{{out}}

</pre>

</small>

 

=={{header|Wren}}==

{{trans|Kotlin}}

{{libheader|DOME}}

import "dome" for Window

 

 

var Game = MandelbrotSet.new(800, 600)</syntaxhighlight>

 

=={{header|XPL0}}==