Pythonでつくって遊ぶフラクタル

フラクタルは数学やプログラミングの教材としてとても良いですね。練習がてらにスクラッチしたフラクタル図形を紹介します。

理論の解説はしません。

## マンデルブロ集合
全体のコードは[こちら](https://gist.github.com/kazucmpt/354c3e4eedc4bfd157e00c815ddb0135)。

フラクタルと言えば、マンデルブロ集合ですよね。

><font color="MediumVioletRed">定義
$z_0=0, z_{n+1} = z_n^2 + C$で定義される複素数列$\\{z_n \\}$が$n \to \infty $ で発散しない複素平面上の点$C$の集合をマンデルブロ集合と呼ぶ。
</font>

ここで複素数列$\\{z_n \\}$が$n \to \infty $で発散しない、というのは、$|z_n|$が$n \to \infty $で発散しないことを言います。また、$|z_k| > 2$ を満たす $z_k$が存在する場合は$\\{z_n \\}$がいずれ発散することが知られています。この命題の説明は[こちら](http://mrob.com/pub/muency/escaperadius.html)にあります。

そこで、各$C$に対して$\\{z_n \\}$を100項目まで求めて、絶対値が2を超えるものがあるか否かで収束判定を行います。マンデルブロ集合には様々な彩色方法がありますが、今回は、収束判定に要したiterの回数に伴ってカラーリングをすることにします。

``` python3:mandelbrot_set.py
solutions = np.array([2.7693, 0.11535-0.58974J, 0.11535+0.58974J])

def f(z, C):
    return z*z + C

def convergence_judgment(C):
    z = inital_z # 0.0
    i = 0
    while i < 100:
        z = f(z, C)   
        if abs(z) > 2:
            return i #2を超える最小の|z_n|に対応するnをかえす。

        i += 1 
    return i #発散しない場合は100をかえす。


```

main関数では、中心座標center_positionを中心とした一片の長さがepsilonの長方形をN×Nのgridに小分けして、各gridにおいて収束判定を行う旨を書きます。

``` python3:mandelbrot_set.py
N = 1000
inital_z = 0

epsilon = 1 #<2
center_position = [0, 0]

def main():
    grid = np.empty((N, N), dtype=np.uint8)
    points_x = np.linspace(center_position[0]-epsilon, center_position[0]+epsilon, N)
    points_y = np.linspace(center_position[1]-epsilon, center_position[1]+epsilon, N)

    for n, ReC in tqdm(enumerate(points_x)):
        for m, ImC in enumerate(points_y):
            C = ReC + ImC*1J
            grid[m, n] = convergence_judgment(C)

    show(grid)
```

このコードでは計算時間はN=1000でおよそ100秒でした。画像クリックで拡大。

|<img src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/139546/b4239eff-d3b1-fd5d-9f12-7d8ade290c63.png" width=100%>|<img src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/139546/d249f56d-a0bd-96fa-fa04-71199786b079.png" width=100%>|<img src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/139546/c5a12021-55ad-fa3f-3244-e81ad83e4670.png" width=100%>|
|---|---|---|
|(0,0)|(-0.53 -0.613)|(-0.76,0.067)|

なお、マンデルブロ集合の定義から外れてしまいますが、初項$z_0$を変えてみると、これまた特徴的な様子が見えてきて楽しいですよ！それと、z^2 + C の指数2を色々かえてみて任意のnについて z^n + C のつくる模様をみてみると楽しいですよ！

## ニュートンフラクタル
全体のコードは[こちら](https://gist.github.com/kazucmpt/be81fb250fc62827ee1435f27101c046)。

例えば複素数$z$に関する3次方程式

$$
z^3-3z^2+z-1=0\tag{1}
$$

は3つの解をもつ。怠慢なので[Mathics](https://mathics.angusgriffith.com/)などで次のように入力すれば、解が求まりますね。![no.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/139546/24ac3f84-9444-dc6d-7726-2a5d09b6391d.png)

複素平面上の任意の点を始点$z_0$として、ニュートン法

$$
z_{n+1} = z_{n} - \frac{f(z_n)}{f'(z_n)}
$$

で$z$を更新していって方程式(1)の解を見つけることを考えます。もちろん、方程式(1)の左辺は$z$に関して単調ではないので、ニュートン法によって解が求まるかは分かりません。適当に選んだ$z_0$に対して、ニュートン法の結果

1. 解１にたどり着く
2. 解２にたどり着く
3. 解３にたどり着く
4. どこにもたどり着かない(ニュートン法によって収束しない）

のいずれかの結果が得られます。ニュートン法の各始点$z_0$に対して上記1~4のどの結果が得られるかによって複素平面上の点$z_0$を色付けします。

```Python:newton_fractal.py
def f(z):
    return z**3-3*z**2+z-1

def diff_f(z):
    return 3*z**2-6*z+1

def find_nearest_solution_idx_and_residual(z):
    nearest_solution_idx = abs(z-solutions).argmin()
    residual = abs(z - solutions[nearest_solution_idx])
    
    return nearest_solution_idx, residual 

def solve_f(inital_z):
    z = inital_z
    for n in range(max_step):
        z = z - f(z) / diff_f(z)
        nearest_solution_idx, residual = find_nearest_solution_idx_and_residual(z)
        if residual < residual_criteria: #convergence judgment
            return nearest_solution_idx + 2*n/max_step

    return len(solutions)
```

すると以下のようなフラクタルが現れます。計算時間はN=2500で24分でした。

|<img src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/139546/e6da9d4c-ad9e-1ea2-39a7-8ba37ca92d1d.png" width=100%>|<img src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/139546/b2858f6f-e07d-8547-4149-14ed3be29957.png" width=100%>|<img src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/139546/b961275d-faa5-79e0-d7d1-487edffccf14.png" width=100%>|
|---|---|---|


方程式をいろいろ変えてみて遊んでみると楽しいですよ！


[1] [稲生啓行 複素力学系と計算可能性](https://www.math.kyoto-u.ac.jp/insei/?plugin=attach&pcmd=open&file=Inou.pdf&refer=KINOSAKI%20SEMINAR%202009%2Fattach)

## シェルピンスキーのギャスケット

全体のコードは[こちら](https://gist.github.com/kazucmpt/1e913d1b9bf1ad5859ebc0759befd923)

シェルピンスキーのガスケットのガスケットは次のアルゴリズムで生成されます。

1. 正三角形(a1, a2, a3)の座標を適当に決める。
2. 正三角形(a1, a2, a3)の各辺の中点を結ぶ。
3. 2.の手続きによって出現した4つの三角形のうち、中央の三角形を除く3つの三角形について2を行う。

以下のソースコードでは、便利なので座標に複素数を用いていますが、これは本質ではありません。triangleは3つの要素を持つリストで、各要素が三角形の頂点の複素座標に対応しています。

```Python3:sierpinski_gasket_fractals.py
#ひとつの三角形から三つの三角形を生成する。
def make_3triangles_from_triangle(triangle):
    p0 = triangle[0]
    p1 = triangle[1]
    p2 = triangle[2]

    new_p2 = (m*p0 + n*p1) / (m+n)
    new_p0 = (m*p1 + n*p2) / (m+n)
    new_p1 = (m*p2 + n*p0) / (m+n)

    triangle0 = [p0, new_p1, new_p2]
    triangle1 = [new_p1, p2, new_p0]
    triangle2 = [new_p2, new_p0, p1]
    
    return triangle0, triangle1, triangle2 

def get_new_triangles(triangles):
    new_triangles = []
    for i, triangle in enumerate(triangles):
        triangle0, triangle1, triangle2 = make_3triangles_from_triangle(triangles[i])
        new_triangles.append(triangle0)
        new_triangles.append(triangle1)
        new_triangles.append(triangle2)

    return new_triangles
```

せっかくなので周の長さの和と面積を求めてみます。理論的には、周の長さは無限大、面積は0に収束していくはずです。

```Python3:sierpinski_gasket_fractals.py
def get_circumference_and_area(triangles):
    distance_between_two_point = abs(triangles[-1][0] - triangles[-1][1])
    circumference = len(triangles) * distance_between_two_point
    area = math.sqrt(3)/4.0 * distance_between_two_point ** 2
    return circumference, area
```

プログラムを実行してみると周の長さは大きくなっていき、面積は0に収束していく様子が分かります。

```
depth:0 num_triangles:3 circumference:1.50000 area:0.10825 time:0.000010 [sec]
depth:1 num_triangles:9 circumference:2.25000 area:0.02706 time:0.000118 [sec]
depth:2 num_triangles:27 circumference:3.37500 area:0.00677 time:0.000203 [sec]
depth:3 num_triangles:81 circumference:5.06250 area:0.00169 time:0.000349 [sec]
depth:4 num_triangles:243 circumference:7.59375 area:0.00042 time:0.000826 [sec]
depth:5 num_triangles:729 circumference:11.39062 area:0.00011 time:0.001953 [sec]
depth:6 num_triangles:2187 circumference:17.08594 area:0.00003 time:0.006996 [sec]
depth:7 num_triangles:6561 circumference:25.62891 area:0.00001 time:0.044693 [sec]
depth:8 num_triangles:19683 circumference:38.44336 area:0.00000 time:0.117012 [sec]
depth:9 num_triangles:59049 circumference:57.66504 area:0.00000 time:0.377997 [sec]
drawing...
```


せっかくなのでアニメーションにしてみました。

<img src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/139546/828c172a-713d-fe97-16e1-d897bf581c0f.gif" width=50%>

ちょっとソースコードを変えてみて、変態なシェルピンスキーのガスケットを作ってみました。
<img src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/139546/a9d0fb32-37c8-4087-371f-a5cce3ec0387.png" width=50%>
こちらも周の長さは発散して、面積は0に収束します。

## ドラゴン曲線
全体のコードは[こちら](https://gist.github.com/kazucmpt/1411604142478e21478d734a7f3751cf)。

下の図のように各ステップで線分の終点を中心に90度回転させた像を足していくとドラゴン曲線と呼ばれる曲線絵が描けます。

![un.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/139546/9e1f8ce9-3e1f-b5a8-6ede-214a8e933526.png)



点$(x, y)$を点$(C_x, C_y)$を中心に$θ$だけ回転させると点$(x, y)$は

```math
x_{new} = x\cos{\theta} - y\sin{\theta} + C_x - C_x\cos{\theta} + C_y\sin{\theta}  \\ 
y_{new} = x\sin{\theta} + y\cos{\theta} + C_y - C_x\sin{\theta} - C_y\cos{\theta}
```
に移動します。これを簡単のために

```math
x_{new} = f_x(x,y,C_{x},C_{y})  \\ 
y_{new} = f_y(x,y,C_{x},C_{y})
```
と書くことにします。

深さ$j$では新しく$2^j$個の点が出現します。新たに出現する$2^j$個の点を$x_{new}^{(k)}$, $y_{new}^{(k)}$と書くことにします。ただし、$k = 1, 2, … ,2^j$ です。すると、深さ$j$では、各$k$について

```math
x_{new}^{(k)} = f_x(x_{2^j-k},y_{2^j-k},x_{2^j},y_{2^j})  \\ 
y_{new}^{(k)} = f_y(x_{2^j-k},y_{2^j-k},x_{2^j},y_{2^j})
```

を計算することで新たに加わる座標を得ることができます。

```python:DragonCurve.py
def get_rotate_coordinate(x, y, Cx, Cy, theta=Pi/2):
    newx = x*math.cos(theta)-y*math.sin(theta)+Cx-Cx*math.cos(theta)+Cy*math.sin(theta)
    newy = x*math.sin(theta)+y*math.cos(theta)+Cy-Cx*math.sin(theta)-Cy*math.cos(theta)
    return newx, newy

def main():
    # Initial Condition
    xs = [1, 0]
    ys = [1, 1]

    for depth in range(max_depth):
        for k in range(2**depth):
            newx, newy = get_rotate_coordinate(xs[2**depth-k-1], ys[2**depth-k-1], Cx=xs[2**depth], Cy=ys[2**depth])
            xs.append(newx)
            ys.append(newy)
        print("depth:{} length:{}".format(depth, len(xs)-1))
    
    print("drawing..")
    draw(xs, ys)
```

こうして得た図が以下です。

|<img src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/139546/87e3b16f-eb74-a59c-019d-9d794886e003.png" width=100%>|<img src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/139546/bc735462-62bf-3c58-c14e-b916203e3321.png" width=100%>|<img src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/139546/625f8990-ddc5-170b-0597-ebfc73ac5a67.png" width=100%>|
|---|---|---|
|depth 5|depth 10|depth 20|

回転角を$\theta=90°$からずらしてみると、ドラゴン曲線の形が連続変形されて行っておもしろいですよ！