File:Collatz Fractal.jpg

本预览的尺寸：800 × 343像素。其他分辨率：320 × 137像素 | 640 × 274像素 | 1,024 × 439像素 | 1,280 × 549像素 | 2,560 × 1,097像素 | 40,320 × 17,280像素。

原始文件（40,320 × 17,280像素，文件大小：46.24 MB，MIME类型：image/jpeg）

本文件并非来自中文维基百科，而是来自维基共享资源。请参阅维基共享资源上的详细描述、讨论页、页面历史、日志。

维基共享资源是一个储存自由版权作品的项目。您可以向此项目作出贡献。

摘要

警告	部分浏览器在浏览此图片的完整大小时可能会遇到困难：该图片中有数量巨大的像素点，可能无法完全载入或者导致您的浏览器停止响应。	交互式大图查看器

描述

English: A Collatz fractal for the interpolating function

f(z)={\tfrac {z}{2}}\cos ^{2}\left({\tfrac {\pi }{2}}z\right)\,+\,{\tfrac {3z+1}{2}}\sin ^{2}\left({\tfrac {\pi }{2}}z\right)+{\tfrac {1}{\pi }}\left({\tfrac {1}{2}}-\cos(\pi z)\right)\sin(\pi z)

.^[1] The center of the image is

z=0

and the real part goes from

-5

to

5

.

↑ (1999). "The (3n + 1)-problem and holomorphic dynamics". Experimental Mathematics 8 (3): 241–252. DOI:10.1080/10586458.1999.10504402.

日期

2023年10月6日

来源

自己的作品

作者

Hugo Spinelli

其他版本

This image is a JPEG version of the original PNG image at File: Collatz Fractal.png.

Generally, this JPEG version should be used when displaying the file from Commons, in order to reduce the file size of thumbnail images. However, any edits to the image should be based on the original PNG version in order to prevent generation loss, and both versions should be updated. Do not make edits based on this version. See here for more information.

Source code

Python code

import enum
import itertools
import time
from math import floor, ceil

import numba as nb
import numpy as np
import matplotlib
from PIL import Image, PyAccess


# Amount of times to print the total progress
PROGRESS_STEPS: int = 20

# Set to `True` to plot the shortcut version of the fractal
SHORTCUT: bool = True

# Make all integers critical points
FIX_CRITICAL_POINTS: bool = True

# Width of the image in pixels and aspect ratio
RESOLUTION: int = 1920*1080//4
ASPECT_RATIO: float = 21/9 if FIX_CRITICAL_POINTS else 16/9

# Value of the center pixel
CENTER: complex = 0 + 0j

# Value range of the real part (width of the horizontal axis)
RE_RANGE: float = 10 if FIX_CRITICAL_POINTS else 5

# Show grid lines for integer real and imaginary parts
SHOW_GRID: bool = False
GRID_COLOR: tuple[int, int, int] = (125, 125, 125)

# Matplotlib named colormap
COLORMAP_NAME: str = 'inferno'

# Plot range of the axes
X_MIN = CENTER.real - RE_RANGE/2  # min Re(z)
X_MAX = CENTER.real + RE_RANGE/2  # max Re(z)
Y_MIN = CENTER.imag - RE_RANGE/(2*ASPECT_RATIO)  # min Im(z)
Y_MAX = CENTER.imag + RE_RANGE/(2*ASPECT_RATIO)  # max Im(z)

x_range = X_MAX - X_MIN
y_range = Y_MAX - Y_MIN
pixels_per_unit = np.sqrt(RESOLUTION/(x_range*y_range))

# Width and height of the image in pixels
WIDTH = round(pixels_per_unit*x_range)
HEIGHT = round(pixels_per_unit*y_range)


# Maximum iterations for the divergence test (recommended >= 60)
MAX_ITER: int = 60


# Max value of Re(z) and Im(z) for which the recursion doesn't overflow
CUTOFF_RE = 7.564545572282618e+153
CUTOFF_IM = 112.10398935569289 if SHORTCUT else 111.95836403625282

# Smallest positive real fixed point
INNER_FIXED_POINT = 0.277733766171606 if SHORTCUT else 0.150108511304474


# Precompute the colormap
CMAP_LEN: int = 2000
cmap_mpl = matplotlib.colormaps[COLORMAP_NAME]
# Start away from 0 (discard black values for the 'inferno' colormap)
# Matplotlib's colormaps have 256 discrete color points
n_cmap = round(256*0.98)
CMAP = [cmap_mpl(k/256) for k in range(256 - n_cmap, 256)]
# Interpolate
x = np.linspace(0, 1, num=CMAP_LEN)
xp = np.linspace(0, 1, num=n_cmap)
c0, c1, c2 = tuple(np.interp(x, xp, [c[k] for c in CMAP]) for k in range(3))
CMAP = []
for x0, x1, x2 in zip(c0, c1, c2):
    CMAP.append(tuple(round(255*x) for x in (x0, x1, x2)))


class DivType(enum.Enum):
    """Divergence type."""

    CONVERGED = -1  # Converged
    MAX_ITER = 0  # Maximum iterations reached
    CUTOFF_RE = 1  # Diverged by exceeding the real part cutoff
    CUTOFF_IM = 2  # Diverged by exceeding the imaginary part cutoff


@nb.jit(nb.float64(nb.float64, nb.int64), nopython=True)
def smooth(x, k=1):
    """Recursive exponential smoothing function."""

    y = np.expm1(np.pi*x)/np.expm1(np.pi)
    if k <= 1:
        return y
    return smooth(y, np.fmin(6, k - 1))


@nb.jit(nb.float64(nb.float64, nb.float64), nopython=True)
def get_delta(x, cutoff):
    """Get the fractional part of the smoothed divergence count."""

    nu = np.log(np.abs(x)/cutoff)/(np.pi*cutoff - np.log(cutoff))
    nu = np.fmax(0, np.fmin(nu, 1))
    return smooth(1 - nu, 2)


@nb.jit(
    nb.types.containers.Tuple((
        nb.float64,
        nb.types.EnumMember(DivType, nb.int64)
    ))(nb.complex128),
    nopython=True
)
def divergence_count(z):
    """Return a smoothed divergence count and the type of divergence."""

    z_fix = 0 + 0j
    for k in range(MAX_ITER):
        c = np.cos(np.pi*z)
        if SHORTCUT:
            if FIX_CRITICAL_POINTS:
                z_fix = (0.5 - c)*np.sin(np.pi*z)/np.pi
            z = 0.25 + z - (0.25 + 0.5*z)*c + z_fix
        else:  # Regular
            if FIX_CRITICAL_POINTS:
                z_fix = (1.25 - 1.75*c)*np.sin(np.pi*z)/np.pi
            z = 0.5 + 1.75*z - (0.5 + 1.25*z)*c + z_fix

        if np.abs(z.imag) > CUTOFF_IM:
            # Diverged by exceeding the imaginary part cutoff
            return k + get_delta(z.imag, CUTOFF_IM), DivType.CUTOFF_IM
        if np.abs(z.real) > CUTOFF_RE:
            # Diverged by exceeding the real part cutoff
            return k + get_delta(z.real, CUTOFF_RE), DivType.CUTOFF_RE
        if np.abs(z) < INNER_FIXED_POINT:
            # Converged to a fixed point
            return -1, DivType.CONVERGED

    # Maximum iterations reached
    return -1, DivType.MAX_ITER


@nb.jit(nb.float64(nb.float64), nopython=True)
def cyclic_map(g):
    """A continuous function that cycles back and forth from 0 to 1."""

    # This can be any continuous function.
    # Log scale removes high-frequency color cycles.
    freq_div = 12
    g = np.log1p(np.fmax(0, (g - 1)/freq_div))

    # Beyond this value for float64, decimals are truncated
    if g >= 2**51:
        return -1

    # Normalize and cycle
    # g += 0.5  # phase from 0 to 1
    return 1 - np.abs(2*(g - np.floor(g)) - 1)


@nb.jit(nb.complex128(nb.types.containers.UniTuple(nb.float64, 2)),
        nopython=True)
def pixel_to_z(p):
    """Convert pixel coordinates to its corresponding complex value."""

    re = X_MIN + (X_MAX - X_MIN)*p[0]/WIDTH
    im = Y_MAX - (Y_MAX - Y_MIN)*p[1]/HEIGHT
    return re + 1j*im


class Progress:
    """Simple progress check helper class."""

    def __init__(self, n: int, steps: int = 10):
        self.n = n
        self.k = 0
        self.steps = steps
        self.step = 1
        self.progress = 0

    def check(self) -> bool:
        self.k += 1
        self.progress = self.k/self.n
        if self.steps*self.k >= self.step*self.n:
            self.step += 1
            return True
        return self.progress == 1


def create_image():
    img = Image.new('RGB', (WIDTH, HEIGHT))
    pix = img.load()
    pix: PyAccess
    n_pix = WIDTH*HEIGHT

    prog = Progress(n_pix, steps=PROGRESS_STEPS)
    for p in itertools.product(range(WIDTH), range(HEIGHT)):
        c = pixel_to_z(p)
        g, div_type = divergence_count(c)
        if g >= 0:
            pix[p] = CMAP[round(cyclic_map(g)*(CMAP_LEN - 1))]
        else:
            # Color of the interior of the fractal
            pix[p] = (0, 0, 0)
        if prog.check():
            print(f'{prog.progress:<7.1%}')

    if SHOW_GRID:
        for x in range(ceil(X_MIN), floor(X_MAX) + 1):
            px = round((x - X_MIN)*(WIDTH - 1)/(X_MAX - X_MIN))
            for py in range(HEIGHT):
                pix[(px, py)] = GRID_COLOR
        for y in range(ceil(Y_MIN), floor(Y_MAX) + 1):
            py = round((Y_MAX - y)*(HEIGHT - 1)/(Y_MAX - Y_MIN))
            for px in range(WIDTH):
                pix[(px, py)] = GRID_COLOR

    return img


img = create_image()
strtime = time.strftime('%Y%m%d-%H%M%S')
fractal_type = 'Shortcut' if SHORTCUT else 'Regular'
filename = f'Collatz_{fractal_type}_{strtime}.png'
img.save(filename)

许可协议

我，本作品著作权人，特此采用以下许可协议发表本作品：

	本作品采用知识共享 CC0 1.0 通用公有领域贡献许可协议授权。
	采用本宣告发表本作品的人，已在法律允许的范围内，通过在全世界放弃其对本作品拥有的著作权法规定的所有权利（包括所有相关权利），将本作品贡献至公有领域。您可以复制、修改、传播和表演本作品，将其用于商业目的，无需要求授权。 CC0falsefalse

文件历史

点击某个日期/时间查看对应时刻的文件。

	日期/时间	缩⁠略⁠图	大小	用户	备注
当前	2023年10月6日 (五) 18:21		40,320 × 17,280（46.24 MB）	Hugo Spinelli	Uploaded own work with UploadWizard

文件用途

以下页面使用本文件：

考拉兹猜想

全域文件用途

以下其他wiki使用此文件：

en.wikipedia.org上的用途
- Collatz conjecture

[Letherman,_Schleicher,_and_Wood_(1999)-1] (1999). "The (3n + 1)-problem and holomorphic dynamics". Experimental Mathematics 8 (3): 241–252. DOI:10.1080/10586458.1999.10504402.

[1]

File:Collatz Fractal.jpg

摘要

许可协议

说明

此文件中描述的项目

描绘内容

考拉兹猜想 ^{简体中文（已转写）}

分形 ^{中文（已转写）}

创作作者

某些值没有维基数据项目

版权状态

受版权保护，并由版权所有者释出于公有领域 ^{简体中文（已转写）}

许可协议

CC0

文件来源 ^{简体中文（已转写）}

上传者的原创作品 ^{简体中文（已转写）}

成立或创建时间

6 10 2023

多媒体类型

image/jpeg

校验和 ^{简体中文（已转写）}

b61dced6fa253b39785596b854188d24ef209cf2

数据大小 ^{简体中文（已转写）}

48,488,982 字节

高度

17,280 像素

宽度

40,320 像素

文件历史

文件用途

全域文件用途

摘要

许可协议

说明

此文件中描述的项目

考拉兹猜想 简体中文（已转写）

分形 中文（已转写）

某些值没有维基数据项目

受版权保护，并由版权所有者释出于公有领域 简体中文（已转写）

文件来源 简体中文（已转写）

上传者的原创作品 简体中文（已转写）

6 10 2023

image/jpeg

校验和 简体中文（已转写）

b61dced6fa253b39785596b854188d24ef209cf2

数据大小 简体中文（已转写）

48,488,982 字节

17,280 像素

40,320 像素

文件历史

文件用途

全域文件用途

考拉兹猜想 ^{简体中文（已转写）}

分形 ^{中文（已转写）}

受版权保护，并由版权所有者释出于公有领域 ^{简体中文（已转写）}

文件来源 ^{简体中文（已转写）}

上传者的原创作品 ^{简体中文（已转写）}

校验和 ^{简体中文（已转写）}

数据大小 ^{简体中文（已转写）}