Data commit

Task/Mandelbrot-set/Python/mandelbrot-set-1.py

@@ -0,0 +1,18 @@
+# Python 3.0+ and 2.5+
+try:
+    from functools import reduce
+except:
+    pass
+
+
+def mandelbrot(a):
+    return reduce(lambda z, _: z * z + a, range(50), 0)
+
+def step(start, step, iterations):
+    return (start + (i * step) for i in range(iterations))
+
+rows = (("*" if abs(mandelbrot(complex(x, y))) < 2 else " "
+        for x in step(-2.0, .0315, 80))
+        for y in step(1, -.05, 41))
+
+print("\n".join("".join(row) for row in rows))

Task/Mandelbrot-set/Python/mandelbrot-set-2.py

@@ -0,0 +1,14 @@
+import math
+
+def mandelbrot(z , c , n=40):
+    if abs(z) > 1000:
+        return float("nan")
+    elif n > 0:
+        return mandelbrot(z ** 2 + c, c, n - 1)
+    else:
+        return z ** 2 + c
+
+print("\n".join(["".join(["#" if not math.isnan(mandelbrot(0, x + 1j * y).real) else " "
+                 for x in [a * 0.02 for a in range(-80, 30)]])
+                 for y in [a * 0.05 for a in range(-20, 20)]])
+     )

Task/Mandelbrot-set/Python/mandelbrot-set-3.py

@@ -0,0 +1,25 @@
+from pylab import *
+from numpy import NaN
+
+def m(a):
+	z = 0
+	for n in range(1, 100):
+		z = z**2 + a
+		if abs(z) > 2:
+			return n
+	return NaN
+
+X = arange(-2, .5, .002)
+Y = arange(-1,  1, .002)
+Z = zeros((len(Y), len(X)))
+
+for iy, y in enumerate(Y):
+	print (iy, "of", len(Y))
+	for ix, x in enumerate(X):
+		Z[iy,ix] = m(x + 1j * y)
+
+imshow(Z, cmap = plt.cm.prism, interpolation = 'none', extent = (X.min(), X.max(), Y.min(), Y.max()))
+xlabel("Re(c)")
+ylabel("Im(c)")
+savefig("mandelbrot_python.svg")
+show()

Task/Mandelbrot-set/Python/mandelbrot-set-4.py

@@ -0,0 +1,27 @@
+import matplotlib.pyplot as plt
+import numpy as np
+
+npts = 300
+max_iter = 100
+
+X = np.linspace(-2, 1, 2 * npts)
+Y = np.linspace(-1, 1, npts)
+
+#broadcast X to a square array
+C = X[:, None] + 1J * Y
+#initial value is always zero
+Z = np.zeros_like(C)
+
+exit_times = max_iter * np.ones(C.shape, np.int32)
+mask = exit_times > 0
+
+for k in range(max_iter):
+    Z[mask] = Z[mask] * Z[mask] + C[mask]
+    mask, old_mask = abs(Z) < 2, mask
+    #use XOR to detect the area which has changed
+    exit_times[mask ^ old_mask] = k
+
+plt.imshow(exit_times.T,
+           cmap=plt.cm.prism,
+           extent=(X.min(), X.max(), Y.min(), Y.max()))
+plt.show()

Task/Mandelbrot-set/Python/mandelbrot-set-5.py

@@ -0,0 +1,43 @@
+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)
+
+direction, height = 45, 1.5  # direction and height of the incoming light
+v = np.exp(direction / 180 * np.pi * 1j)  # unit 2D vector in this direction
+
+x = np.linspace(0, 2, num=d+1)
+y = np.linspace(0, 2 * h / d, num=h+1)
+
+A, B = np.meshgrid(x - 1, y - h / d)
+C = (2.0 + 1.0j) * (A + B * 1j) - 0.5
+
+Z, dZ, ddZ = np.zeros_like(C), np.zeros_like(C), np.zeros_like(C)
+D, T = np.zeros(C.shape), np.zeros(C.shape)
+
+for k in range(n):
+    M = Z.real ** 2 + Z.imag ** 2 < r ** 2
+    Z[M], dZ[M], ddZ[M] = Z[M] ** 2 + C[M], 2 * Z[M] * dZ[M] + 1, 2 * (dZ[M] ** 2 + Z[M] * ddZ[M])
+
+N = abs(Z) > 2  # exterior distance estimation
+D[N] = np.log(abs(Z[N])) * abs(Z[N]) / abs(dZ[N])
+
+plt.imshow(D ** 0.1, cmap=plt.cm.twilight_shifted, origin="lower")
+plt.savefig("Mandelbrot_distance_est.png", dpi=200)
+
+N = abs(Z) > 2  # normal map effect 1 (potential function)
+U = Z[N] / dZ[N]  # normal vectors to the equipotential lines
+U, S = U / abs(U), 1 + np.sin(100 * np.angle(U)) / 10  # unit normal vectors and stripes
+T[N] = np.maximum((U.real * v.real + U.imag * v.imag + S * height) / (1 + height), 0)
+
+plt.imshow(T ** 1.0, cmap=plt.cm.bone, origin="lower")
+plt.savefig("Mandelbrot_normal_map_1.png", dpi=200)
+
+N = abs(Z) > 2  # normal map effect 2 (distance estimation)
+U = Z[N] * dZ[N] * ((1 + np.log(abs(Z[N]))) * np.conj(dZ[N] ** 2) - np.log(abs(Z[N])) * np.conj(Z[N] * ddZ[N]))
+U = U / abs(U)  # unit normal vectors to the equidistant lines
+T[N] = np.maximum((U.real * v.real + U.imag * v.imag + height) / (1 + height), 0)
+
+plt.imshow(T ** 1.0, cmap=plt.cm.afmhot, origin="lower")
+plt.savefig("Mandelbrot_normal_map_2.png", dpi=200)

Task/Mandelbrot-set/Python/mandelbrot-set-6.py

@@ -0,0 +1,37 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+d, h = 200, 1200  # pixel density (= image width) and image height
+n, r = 8000, 10000  # number of iterations and escape radius (r > 2)
+
+a = -.743643887037158704752191506114774  # real coordinate of the zoom center
+b = 0.131825904205311970493132056385139  # imaginary coordinate of the center
+
+x = np.linspace(0, 2, num=d+1)
+y = np.linspace(0, 2 * h / d, num=h+1)
+
+A, B = np.meshgrid(x * np.pi, y * np.pi)
+C = 8.0 * np.exp((A + B * 1j) * 1j) + (a + b * 1j)
+
+Z, dZ = np.zeros_like(C), np.zeros_like(C)
+D = np.zeros(C.shape)
+
+for k in range(n):
+    M = Z.real ** 2 + Z.imag ** 2 < r ** 2
+    Z[M], dZ[M] = Z[M] ** 2 + C[M], 2 * Z[M] * dZ[M] + 1
+
+N = abs(Z) > 2  # exterior distance estimation
+D[N] = np.log(abs(Z[N])) * abs(Z[N]) / abs(dZ[N])
+
+plt.imshow(D.T ** 0.05, cmap=plt.cm.nipy_spectral, origin="lower")
+plt.savefig("Mercator_Mandelbrot_map.png", dpi=200)
+
+X, Y = C.real, C.imag  # zoom images (adjust circle size 100 and zoom level 20 as needed)
+R, c, z = 100 * (2 / d) * np.pi * np.exp(- B), min(d, h) + 1, max(0, h - d) // 20
+
+fig, ax = plt.subplots(2, 2, figsize=(12, 12))
+ax[0, 0].scatter(X[1*z:1*z+c,0:d], Y[1*z:1*z+c,0:d], s=R[0:c,0:d]**2.0, c=D[1*z:1*z+c,0:d]**0.5, cmap=plt.cm.nipy_spectral)
+ax[0, 1].scatter(X[2*z:2*z+c,0:d], Y[2*z:2*z+c,0:d], s=R[0:c,0:d]**2.0, c=D[2*z:2*z+c,0:d]**0.4, cmap=plt.cm.nipy_spectral)
+ax[1, 0].scatter(X[3*z:3*z+c,0:d], Y[3*z:3*z+c,0:d], s=R[0:c,0:d]**2.0, c=D[3*z:3*z+c,0:d]**0.3, cmap=plt.cm.nipy_spectral)
+ax[1, 1].scatter(X[4*z:4*z+c,0:d], Y[4*z:4*z+c,0:d], s=R[0:c,0:d]**2.0, c=D[4*z:4*z+c,0:d]**0.2, cmap=plt.cm.nipy_spectral)
+plt.savefig("Mercator_Mandelbrot_zoom.png", dpi=100)

Task/Mandelbrot-set/Python/mandelbrot-set-7.py

@@ -0,0 +1,44 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+import decimal as dc  # decimal floating point arithmetic with arbitrary precision
+dc.getcontext().prec = 80  # set precision to 80 digits (about 256 bits)
+
+d, h = 50, 1000  # pixel density (= image width) and image height
+n, r = 80000, 100000  # number of iterations and escape radius (r > 2)
+
+a = dc.Decimal("-1.256827152259138864846434197797294538253477389787308085590211144291")
+b = dc.Decimal(".37933802890364143684096784819544060002129071484943239316486643285025")
+
+S = np.zeros(n+1, dtype=np.complex128)
+u, v = dc.Decimal(0), dc.Decimal(0)
+
+for k in range(n+1):
+    S[k] = float(u) + float(v) * 1j
+    if u ** 2 + v ** 2 < r ** 2:
+        u, v = u ** 2 - v ** 2 + a, 2 * u * v + b
+    else:
+        print("The reference sequence diverges within %s iterations." % k)
+        break
+
+x = np.linspace(0, 2, num=d+1)
+y = np.linspace(0, 2 * h / d, num=h+1)
+
+A, B = np.meshgrid(x * np.pi, y * np.pi)
+C = 8.0 * np.exp((A + B * 1j) * 1j)
+
+E, Z, dZ = np.zeros_like(C), np.zeros_like(C), np.zeros_like(C)
+D, I, J = np.zeros(C.shape), np.zeros(C.shape, dtype=np.int64), np.zeros(C.shape, dtype=np.int64)
+
+for k in range(n):
+    Z2 = Z.real ** 2 + Z.imag ** 2
+    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
+    E[M], I[M] = (2 * S[I[M]] + E[M]) * E[M] + C[M], I[M] + 1
+    Z[M], dZ[M] = S[I[M]] + E[M], 2 * Z[M] * dZ[M] + 1
+
+N = abs(Z) > 2  # exterior distance estimation
+D[N] = np.log(abs(Z[N])) * abs(Z[N]) / abs(dZ[N])
+
+plt.imshow(D.T ** 0.015, cmap=plt.cm.nipy_spectral, origin="lower")
+plt.savefig("Mercator_Mandelbrot_deep_map.png", dpi=200)

Task/Mandelbrot-set/Python/mandelbrot-set-8.py

@@ -0,0 +1,8 @@
+print(
+'\n'.join(
+    ''.join(
+        ' *'[(z:=0, c:=x/50+y/50j, [z:=z*z+c for _ in range(99)], abs(z))[-1]<2]
+        for x in range(-100,25)
+    )
+    for y in range(-50,50)
+))

Task/Mandelbrot-set/Python/mandelbrot-set-9.py

@@ -0,0 +1,5 @@
+from functools import reduce
+
+def mandelbrot(x, y, c): return ' *'[abs(reduce(lambda z, _: z*z + c, range(99), 0)) < 2]
+
+print('\n'.join(''.join(mandelbrot(x, y, x/50 + y/50j) for x in range(-100, 25)) for y in range(-50, 50)))