曼德勃羅集外部的顏色可以是

非平滑 = 逃逸時間 = 駐留時間
- 布林/二進位制逃逸時間方法（bETM/M）
- 離散 = 水平集方法 = LSM/M = 整數 ETM = iETM/M
平滑
- 徑向測量
  - 實數逃逸時間方法（rETM/M）
  - 距離估計方法（DEM/M）
  - 復勢半徑 = 復勢方法（CPM/M）
- 角度測量
  - 復勢的幅角
  - SAC = 條紋平均著色
  - 其他
    - "三角不等式"^[1]^[2]
    - 軌道陷阱^[3]^[4]

還可以繪製曲線

外射線
等勢線（閉合曲線 - 準圓）

類似專案

逃逸時間或駐留時間

這裡，對於引數平面上給定的點 c，人們檢查臨界點 $z=0.0$ 在動力學平面上的前向迭代下的行為。如果你改變初始點，你將得到不同的結果^[5]

要繪製給定的平面，需要檢查/掃描（所有）它的點。參見此處以獲取更多詳細資訊（最佳化）首先閱讀定義。

如何找到逃逸曼德勃羅集所需的迭代次數？

布林逃逸時間

該演算法回答了問題：“對於哪些 c 值，Julia 分形 J(c) 將是線狀的，而對於哪些 c 值將是粉塵狀的？”^[6]

這裡，複平面由 2 個集合組成：曼德勃羅集 $M\,$ 及其補集 $M^{c}\,$

$\mathbb {C} =M\cup M^{c}$

ASCI 圖形（在螢幕上）

// http://mrl.nyu.edu/~perlin/
main(k){float i,j,r,x,y=-16;while(puts(""),y++<15)for(x
=0;x++<84;putchar(" .:-;!/>)|&IH%*#"[k&15]))for(i=k=r=0;
j=r*r-i*i-2+x/25,i=2*r*i+y/10,j*j+i*i<11&&k++<111;r=j);}

-- Haskell code by Ochronus
-- http://blog.mostof.it/mandelbrot-set-in-ruby-and-haskell/
import Data.Complex
mandelbrot a = iterate (\z -> z^2 + a) a !! 500
main = mapM_ putStrLn [[if magnitude (mandelbrot (x :+ y)) < 2 then '*' else ' '
                           | x <- [-2, -1.9685 .. 0.5]]
                           | y <- [1, 0.95 .. -1]]

; common lisp
(loop for y from -1.5 to 1.5 by 0.05 do
      (loop for x from -2.5 to 0.5 by 0.025 do
		(let* ((c (complex x y)) ; parameter
                   	(z (complex 0 0))
                   	(iMax 20) ; maximal number of iterations
			(i 0)) ; iteration number

		(loop  	while (< i iMax ) do 
			(setq z (+ (* z z) c)) ; iteration
			(incf i)
			(when (> (abs z) 2) (return i)))
	   ; color of pixel
           (if (= i iMax) (princ (code-char 42)) ; inside M
                          (princ (code-char 32))))) ; outside M
      (format t "~%")) ; new line

各種語言的比較程式^[7]^[8]

圖形檔案（PPM）

以下是用於建立 pbm 檔案的各種程式^[9]

使用shadertoy 的 GLSL
ed Burke 編寫的簡短 c 程式^[10]

C

這是 C 單檔案程式的完整程式碼。

它建立一個包含影像的 ppm 檔案。要檢視檔案（影像），請使用外部應用程式（圖形檢視器）。
程式由 3 個迴圈組成
- iY 和 iX，用於掃描引數平面的矩形區域
- 迭代。

對於螢幕上的每個點（iX，iY），其複數值將計算為 c=cx+cy*i。

對於每個點，c 都計算了臨界點的迭代次數 $z_{0}=z_{cr}=0\,$

它使用了一些速度改進。不是檢查

sqrt(Zx2+Zy2)<ER

它檢查

(Zx2+Zy2)<ER2 // ER2 = ER*ER

它給出了相同的結果，但速度更快。

 /* 
 c program:
 --------------------------------
  1. draws Mandelbrot set for Fc(z)=z*z +c
  using Mandelbrot algorithm ( boolean escape time )
 -------------------------------         
 2. technique of creating ppm file is  based on the code of Claudio Rocchini
 http://en.wikipedia.org/wiki/Image:Color_complex_plot.jpg
 create 24 bit color graphic file ,  portable pixmap file = PPM 
 see http://en.wikipedia.org/wiki/Portable_pixmap
 to see the file use external application ( graphic viewer)
  */
 #include <stdio.h>
 #include <math.h>
 int main()
 {
          /* screen ( integer) coordinate */
        int iX,iY;
        const int iXmax = 800; 
        const int iYmax = 800;
        /* world ( double) coordinate = parameter plane*/
        double Cx,Cy;
        const double CxMin=-2.5;
        const double CxMax=1.5;
        const double CyMin=-2.0;
        const double CyMax=2.0;
        /* */
        double PixelWidth=(CxMax-CxMin)/iXmax;
        double PixelHeight=(CyMax-CyMin)/iYmax;
        /* color component ( R or G or B) is coded from 0 to 255 */
        /* it is 24 bit color RGB file */
        const int MaxColorComponentValue=255; 
        FILE * fp;
        char *filename="new1.ppm";
        char *comment="# ";/* comment should start with # */
        static unsigned char color[3];
        /* Z=Zx+Zy*i  ;   Z0 = 0 */
        double Zx, Zy;
        double Zx2, Zy2; /* Zx2=Zx*Zx;  Zy2=Zy*Zy  */
        /*  */
        int Iteration;
        const int IterationMax=200;
        /* bail-out value , radius of circle ;  */
        const double EscapeRadius=2;
        double ER2=EscapeRadius*EscapeRadius;
        /*create new file,give it a name and open it in binary mode  */
        fp= fopen(filename,"wb"); /* b -  binary mode */
        /*write ASCII header to the file*/
        fprintf(fp,"P6\n %s\n %d\n %d\n %d\n",comment,iXmax,iYmax,MaxColorComponentValue);
        /* compute and write image data bytes to the file*/
        for(iY=0;iY<iYmax;iY++)
        {
             Cy=CyMin + iY*PixelHeight;
             if (fabs(Cy)< PixelHeight/2) Cy=0.0; /* Main antenna */
             for(iX=0;iX<iXmax;iX++)
             {         
                        Cx=CxMin + iX*PixelWidth;
                        /* initial value of orbit = critical point Z= 0 */
                        Zx=0.0;
                        Zy=0.0;
                        Zx2=Zx*Zx;
                        Zy2=Zy*Zy;
                        /* */
                        for (Iteration=0;Iteration<IterationMax && ((Zx2+Zy2)<ER2);Iteration++)
                        {
                            Zy=2*Zx*Zy + Cy;
                            Zx=Zx2-Zy2 +Cx;
                            Zx2=Zx*Zx;
                            Zy2=Zy*Zy;
                        };
                        /* compute  pixel color (24 bit = 3 bytes) */
                        if (Iteration==IterationMax)
                        { /*  interior of Mandelbrot set = black */
                           color[0]=0;
                           color[1]=0;
                           color[2]=0;                           
                        }
                     else 
                        { /* exterior of Mandelbrot set = white */
                             color[0]=255; /* Red*/
                             color[1]=255;  /* Green */ 
                             color[2]=255;/* Blue */
                        };
                        /*write color to the file*/
                        fwrite(color,1,3,fp);
                }
        }
        fclose(fp);
        return 0;
 }

整數逃逸時間 = LSM/M = 停留帶

細節數量與最大迭代次數成正比
基於每個畫素的固定迭代次數的曼德布羅特動畫。在這裡你可以看到為什麼有時會使用偏移量（因為 - 顏色梯度會發生變化：對於高 MaxIteration 會消失。

這裡顏色與最後一次迭代（final_n，最後一次迭代）成正比。^[11]

這也被稱為水平集方法 ( LSM )

$L_{n}=\{c:z_{n}\in T~~{\mbox{and}}~~z_{k}\notin T~~{\mbox{where}}~~k<n\}\,$

C

曼德布羅特演算法與 LSM/M 之間的區別僅在於部分指令，該指令計算曼德布羅特集外部的畫素顏色。在 LSM/M 中是

 if (Iteration==IterationMax)
   { /* interior of Mandelbrot set = black */
     color[0]=0;
     color[1]=0;
     color[2]=0;                           
   }
   /* exterior of Mandelbrot set = LSM */
   else if ((Iteration%2)==0) 
             { /* even number = black */
             color[0]=0; /* Red */
             color[1]=0; /* Green */ 
             color[2]=0; /* Blue */
             }
           else 
             {/* odd number =  white */
             color[0]=255; /* Red */
             color[1]=255; /* Green */ 
             color[2]=255; /* Blue */    
             };

這裡有一個C函式，沒有顯式的複數，只有雙精度浮點數

int GiveEscapeTime(double C_x, double C_y, int iMax, double _ER2)
{ 
    int i;
    double Zx, Zy;
    double Zx2, Zy2; /* Zx2=Zx*Zx;  Zy2=Zy*Zy  */
 
    Zx=0.0; /* initial value of orbit = critical point Z= 0 */
    Zy=0.0;
    Zx2=Zx*Zx;
    Zy2=Zy*Zy;
 
    for (i=0;i<iMax && ((Zx2+Zy2)<_ER2);i++)
    {
      Zy=2*Zx*Zy + C_y;
      Zx=Zx2-Zy2 +C_x;
      Zx2=Zx*Zx;
      Zy2=Zy*Zy;
    };
 return i;
}

這裡有一個使用複數的簡短程式碼

// https://gitlab.com/adammajewski/mandelbrot_wiki_ACh/blob/master/betm.c
int iterate(double complex C , int iMax)
  {
   int i;
   double complex Z= 0.0; // initial value for iteration Z0
   
   for(i=0;i<iMax;i++)
    {
      Z=Z*Z+C; // https://stackoverflow.com/questions/6418807/how-to-work-with-complex-numbers-in-c
      if(cabs(Z)>EscapeRadius) break;
    }
   return i; 
 }

C++

這裡有一個 C++ 函式，可用於繪製 LSM/M

 int iterate_mandel(complex C , int imax, int bailout)
  {
   int i;
   std::complex Z(0,0); // initial value for iteration Z0
   
   for(i=0;i<=imax-1;i++)
    {
      Z=Z*Z+C; // overloading of operators
      if(abs(Z)>bailout)break;
    }
   return i;
 }

我認為它不能更簡單地編寫（它看起來比虛擬碼更好），但它可以用其他方法編寫，這些方法可以更快地執行。

這裡是一個更快的程式碼

// based on cpp code by Geek3
inline int fractal(double cx, double cy, int max_iters)
// gives last iteration 
{
	double zx = 0, zy = 0;	
	if (zx * zx + zy * zy > 4) return(0); // it=0
	for (int it = 1; it < max_iters; it++)
	{	double zx_old = zx;
		zx = zx * zx - zy * zy;
		zy = 2 * zx_old * zy;
		zx += cx;
		zy += cy;
		if (zx * zx + zy * zy > 4.0) return(it);
	}
	return(max_iters);
}

稍微優化了一下

// optimised from cpp code by Geek3
inline int fractal(double cReal, double cImg, int max_iters)
// gives last iteration 
{
	double zReal = 0, zImg = 0, zReal2 = 0, zImg2 = 0;
	//iteration zero is always 0^2+0^2, it will never escape
	for (int it = 1; it < max_iters; it++)
	{	//because we have zReal^2 and zImg^2 pre-calculated
		//we can calculate zImg first
		//then we don't need to calculate/store the "old" zReal
		zImg = (2 * zReal * zImg ) + cImg;
		zReal = zReal2 - zImg2 + cReal;

		// calculate next iteration: zReal^2 and zImg^2
		// they are used twice so calculate them once
		zReal2 = zReal * zReal;
		zImg2 = zImg * zImg;
		if (zReal2 + zImg2 > 4.0) return(it);
	}
	return(max_iters);
}

See also :

用 C++ 渲染曼德布羅特集：第 1 部分 - 儲存影像，由 Superdavo0001 製作的影片

GLSL

shadertoy

Java

//Java code by Josef Jelinek 
// http://java.rubikscube.info/
 
 int mandel(double cx, double cy) {
    double zx = 0.0, zy = 0.0;
    double zx2 = 0.0, zy2 = 0.0;
    int iter = 0;
    while (iter < iterMax && zx2 + zy2 < 4.0) {
      zy = 2.0 * zx * zy + cy;
      zx = zx2 - zy2 + cx;
      zx2 = zx * zx;
      zy2 = zy * zy;
      iter++;
    }
    return iter;
  }

Java 指令碼

這裡有一個 JavaScript 函式，它不返回最後一次迭代，而是返回 LastIteration 模 maxCol。它使顏色迴圈（如果 maxCol < maxIt）。

function iterate(Cr,Ci) {
// JavaScript function by Evgeny Demidov
// http://www.ibiblio.org/e-notes/html5/fractals/mandelbrot.htm
  var I=0, R=0,  I2=0, R2=0,   n=0;
  if (R2+I2 > max) return 0;
  do  {  I=(R+R)*I+Ci;  R=R2-I2+Cr;  R2=R*R;  I2=I*I;  n++;
  } while ((R2+I2 < max) && (n < maxIt) );
  if (n == maxIt) return maxCol;  else return n % maxCol;
}

上面的函式沒有使用複數的顯式定義。

可汗學院

可汗學院曼德布羅特集

Lisp 程式

基於Frank Buss 的程式碼^[12] ^[13]製作 ASCII 圖形的完整 Lisp 程式

; common lisp
(loop for y from -1.5 to 1.5 by 0.1 do
      (loop for x from -2.5 to 0.5 by 0.04 do
            (let* ((i 0)
                   (z (complex x y))
                   (c z))
              (loop while (< (abs
                              (setq z (+ (* z z) c)))
                             2)
                    while (< (incf i) 32))
              (princ (code-char (+ i 32))))) ; ASCII chars <= 32 contains non-printing characters
      (format t "~%"))

用於Gimp的 MathMap 外掛

filter mandelbrot (gradient coloration)
    c=ri:(xy/xy:[X,X]*1.5-xy:[0.5,0]);
    z=ri:[0,0]; # initial value z0 = 0 
    # iteration of z
    iter=0;
    while abs(z)<2 && iter<31
    do
        z=z*z+c;  # z(n+1) = fc(zn)
        iter=iter+1
    end;
    coloration(iter/32) # color of pixel
end

Pov-Ray

Pov-Ray 有一個內建函式 mandel^[14]

Wolfram Mathematica

這裡有一個由 Paul Nylander 編寫的程式碼

逃逸時間方法的水平曲線 = LCM/M

勒尼薩卡特是逃逸時間水平集 ( LSM/M ) 的邊界。可以使用繪製它們

水平集的邊緣檢測。
- M. Romera 等人在論文中描述的演算法^[15]。這種方法速度很快，可以查詢高迭代次數。
邊界跟蹤^[16]
繪製曲線 $L_{n}(T)=\{c:abs(z_{n})=ER\}\,$ ，請參閱解釋和原始碼。此方法對於迭代次數 > 5 非常複雜。

用於曼德布羅特集繪製的目標集分解

分解是對逃逸時間演算法的修改。

目標集被分成多個部分（2 個或更多）。使用非常大的逃逸半徑，例如 ER = 12。

LSM/M 的二進位制分解

這裡目標集合 $T\,$ 在動態平面上被分為兩部分（二進位制分解 = 2 分解）

上半部分（白色） $T_{u}=\{z:|z|>ER~~{\mbox{and}}~~Im(z)>0\}\,$
下半部分（黑色） $T_{l}=\{z:|z|>ER~~{\mbox{and}}~~Im(z)\leq 0\}\,$

目標集合的劃分導致級別集 $L_{n}\,$ 分解為 $2^{n+1}\,$ 部分（單元格，子集）

$L_{n,u}=\{c:|z_{n}|>ER~~{\mbox{and}}~~Im(z_{n})>0\}\,$ ，顏色為白色，
$L_{n,l}=\{c:|z_{n}|>ER~~{\mbox{and}}~~Im(z_{n})\leq 0\}\,$ ，顏色為黑色。

"The Level Sets and Field Lines are superimposed, creating a sort of grid, and the "squares" of the grid are filled with N-digit binary numbers giving the first N binary digits of the external angles of field lines passing through the square. (Alternately, only the Nth binary digit is used.) Each level set is divided into 2n squares. It is easy to "read" the external arguments of points in the boundary of the Mandelbrot Set using a binary decomposition." Robert P. Munafo

對於二進位制分解，使用 exp(pi) 作為逃逸半徑，以便方框看起來是方形的（來自 mrob 的提示）。

角度為（以圈數測量）

$angle=(k/2^{n})~~{\mbox{mod }}~1\,$

可以被視為子集的邊界。

二進位制分解演算法與 Mandel 或 LSM/M 之間的區別僅在於計算 Mandelbrot 集合外部畫素顏色的指令部分。在二進位制分解中，

 if (Iteration==IterationMax)
  { /* interior of Mandelbrot set = black */
   color[0]=0;
   color[1]=0;
   color[2]=0;           
  }
  /* exterior of Mandelbrot set = LSM */
  else if (Zy>0) 
         { 
          color[0]=0; /* Red */
          color[1]=0; /* Green */ 
          color[2]=0; /* Blue */
         }
        else 
          {
           color[0]=255; /* Red */
           color[1]=255; /* Green */ 
           color[2]=255; /* Blue */    
          };

還有來自 Fragmentarium 的 GLSL 程式碼。

#include "2D.frag"
#group Simple Mandelbrot

// maximal number of iterations
uniform int iMax; slider[1,100,1000] // increase iMax
// er2= er^2 wher er= escape radius = bailout
uniform float er2; slider[4.0,1000,10000] // increase er2

// compute color of pixel
 vec3 color(vec2 c) {
   vec2 z = vec2(0.0);  // initial value

 // iteration
  for (int i = 0; i < iMax; i++) {
    z = vec2(z.x*z.x-z.y*z.y,2*z.x*z.y) +  c; // z= z^2+c
    if (dot(z,z)> er2)   // escape test 
      // exterior
      if (z.x>0){ return vec3( 1.0);} // upper part of the target set 
      else return vec3(0.0); //lower part of the target set 
  }
  return vec3(0.0); //interior
}

// zoomasm -- zoom video assembler
// (c) 2019,2020,2021,2022 Claude Heiland-Allen
// SPDX-License-Identifier: AGPL-3.0-only

// recommended KF bailout settings: linear smoothing, custom radius 25
vec3 colour(void)
{
  if (getInterior())
  {
    return vec3(1.0, 0.0, 0.0);
  }
  bool decomp = getT() < 0.5;
  return vec3(decomp ? 0.0 : 1.0);
}

如果最後一次迭代的虛部 (Zy) 為正或負，則點 c 繪製為白色或黑色。^[17]

n 分解

此方法是二進位制分解的擴充套件。

目標集 T = { z : |zn| > R } 具有非常大的逃逸半徑（例如 R = 12），被劃分為多於 2 部分（例如 8）。^[18]

真實逃逸時間

此方法/演算法的其他名稱是：

完全重整化的分數迭代計數（由 Linas Vepstas 於 1997 年提出）^[19]
廣義 Mandelbrot 集合的平滑迭代計數（由 Inigo Quilez 於 2016 年提出）^[20]
Mandelbrot 集合的連續迭代計數
歸一化迭代計數演算法
連續著色
平滑顏色漸變
分數迭代
分數逃逸時間

這裡 Mandelbrot 集合外部的顏色不是與最後一次迭代（它是整數）成正比，而是與實數成正比

\nu (z)=\lim _{i\to \infty }(i-\log _{2}\log _{2}|z_{i}|)\,

其他方法和加速方法

Ultrafractal 中的著色公式：^[21]

smooth iter = iter + 1 + ( log(log(bailout)-log(log(cabs(z))) )/log(2)

其中：

log(log(bailout) 可以預先計算

理論

克勞德的描述

首次描述

如果 R 很大，第一個逃逸的 z 滿足（近似）：^[22]

 $R<|z|<R^{p}$

所以取對數

 $\log(R)<\log(|z|)<p\log(R)$

所以再取一次對數

 $\log(\log(R))<\log(\log(|z|))<\log(p)+\log(\log(R))$

所以根據代數

 $0<{\frac {\log(\log(|z|))-\log(\log(R))}{\log(p)}}<1$

當 $|z|$ 在逃逸時更大，平滑迭代次數應該更小，所以這個值需要從整數迭代次數中減去

或者，這個分數可以用於插值，或者與 arg(z) 一起用於外部平鋪/二進位制分解。

第二次描述^[23]

選擇一個半徑 R > 2，然後 |Z| > R 意味著 |Z^2 + C| > |Z|，更一般地，|Z| -> 無限大，這給 R 起了逃逸半徑的名字。證明在 math.stackexchange.com 上 somewhere。

現在假設 R 很大，n 是第一次 |Z_n| > R 的迭代。

考慮當您將點 C 從曼德勃羅集邊界稍微移開時，|Z_n| 會怎樣增加。

最終 |Z_n| > R^2，但隨後 |Z_{n-1}| > R，所以迭代次數應該是 n - 1。

為了平滑，我們想要一個值加到 n 上，當 |Z_n| = R 時為 0，當 |Z_n| = R^2 時為 -1。

取對數，得到 log |Z| 在 log(R) 和 2 log(R) 之間

再次取對數，得到 log log |Z| 在 log log R 和 log log R + log 2 之間

除以 log 2，得到 log_2 log |Z| 在 log_2 log R 和 log_2 log R + 1 之間

減去 log_2 log R 給出 (log_2 log |Z| - log_2 log R) 在 0 和 1 之間

否定它給出介於 0 和 -1 之間的值，如預期

所以平滑迭代次數是

 $n-(log_{2}log|Z|-log_{2}logR)$

（如果你做 Z^P + C，將 2 替換為 P）

另請參閱 http://linas.org/art-gallery/escape/escape.html，它會生成一個與 R 無關的值，但這對於某些著色演算法來說不是很有用（例如，逃逸計數的平滑部分不與最終迭代的角度對齊）

C

要在程式開頭新增 log2 函式，請新增：

#include <math.h>

在程式開頭。

if (Iteration==IterationMax)
 { /*  interior of Mandelbrot set = black */
  color[0]=0;
  color[1]=0;
  color[2]=0;                           
 }
 /* exterior of Mandelbrot set  */
 else GiveRainbowColor((double)(Iteration- log2(log2(sqrt(Zx2+Zy2))))/IterationMax,color);

其中：

Zx2 = Zx*Zx
Zy2 = Zy*Zy

以下是 Tony Finch 的另一個版本^[24]

while (n++ < max &&
 x2+y2 < inf) {
y = 2*x*y + b;
x = x2-y2 + a;
y2 = y*y;
x2 = x*x;
}
nu = n - log(log(x2+y2)/2)/ log(2);

基於公式^[25]

\nu (z)=n-\log _{2}\log(z_{n})\,

C++

// based on cpp code by Geek3 from https://wikibook.tw/wiki/File:Mandelbrot_set_rainbow_colors.png
sqrxy = x * x + y * y;
double m = LastIteration + 1.5 - log2(log2(sqrxy));

java

 /**
Smooth coloring algorithm
https://gitlab.com/shreyas.siravara/mandelbrot-with-smooth-coloring/blob/master/Mandelbrot.java
Mandelbrot with Smooth Coloring by Shreyas Siravara

*/
                double nsmooth = (iterations + 1 - Math.log(Math.log(Zn.getMagnitude())) / Math.log(ESCAPE_RADIUS));

                double smoothcolor = nsmooth / MAX_ITERATIONS;

                if (iterations < MAX_ITERATIONS) {
                    int rgb = Color.HSBtoRGB((float) (0.99f + 1.9 * smoothcolor), 0.9f, 0.9f);
                    g2d.setColor(new Color(rgb));
                } else {
                    g2d.setColor(Color.black.darker());
                }

Matemathica

以下是 Paul Nylander 的程式碼。它使用不同的公式

$cet=n+log_{2}ln(R)-log_{2}ln|z|$

Python

使用 mpmath 庫的 Python 程式碼^[26]

def mandelbrot(z):
    c = z
    for i in xrange(ITERATIONS):
        zprev = z
        z = z*z + c
        if abs(z) > ESCAPE_RADIUS:
            return ctx.exp(1j*(i + 1 - ctx.log(ctx.log(abs(z)))/ctx.log(2)))
    return 0

距離估計 DEM/M

外部 DEM/M
使用 DEM/M 的簡單邊界
使用 DEM/M 和 Sobel 濾波器的邊界

變體

外部 DEM/M
內部 DEM/M

描述

復勢

描述

另請參閱

參考資料

[1] 發散分形的數學 by

[2] ussi harkonen : 著色技術

[3] 維基百科 : 軌道陷阱

[4] 曼德勃羅軌道陷阱渲染！程式設計教程影片 by DKM101

[5] Dieter Röß 編寫的 Java 程式，展示了改變曼德勃羅迭代初始點的結果

[6] PostScript 中的 Julia 分形 by Kees van der Laan, EUROTEX 2012 & 6CM PROCEEDINGS 47

[7] 分形基準測試 by Erik Wrenholt

[8] 12 分鐘曼德勃羅：50 年前的 IBM 1401 大型機上的分形

[9] 計算機語言基準測試遊戲

[10] 演示程式碼示例 - 以多種方式檢視 Julia 集 by ed Burke

[11] 計算曼德勃羅集 by Andrew Williams

[12] LIsp 程式 by Frank Buss

[13] Bill Clementson 部落格中的曼德勃羅集 ASCII 藝術

[14] 來自 2.5.11.14 分形模式的曼德勃羅函式 at Pov-Ray 文件

[15] 透過逃逸線方法繪製曼德勃羅集。M. Romera 等人。

[16] ttp://www.metabit.org/~rfigura/figura-fractal/math.html 邊界跟蹤 by Robert Figura

[17] ttp://web.archive.org/20010415125044/www.geocities.com/CapeCanaveral/Launchpad/5113/fr27.htm%7C 喬伊斯·哈斯拉姆在FRACTAL REPORT 27中緻密奇博士的公開信

[18] 曼德博集合 n 次分解

[19] s.org : 曼德博逃逸的重整化

[20] I Quilez : mset_smooth

[21] ractalforums : 曼德博/朱利亞集合的分數逃逸計數的範圍/精度是多少？

[22] ractalforums : 使用兩種顏色的漸變調色盤

[23] ractalforums.org : 有人可以幫我理解平滑著色嗎

[24] 託尼·芬奇製作曼德博集電影

[25] Linas Vepstas. 重整化曼德博逃逸.

[26] th Python 庫

[1]

[2]

[3]

[4]

[5]

[6]

[7]

[8]

[9]

[10]

[11]

[12]

[13]

[14]

[15]

[16]

[21]

[22]

[23]

[24]

[25]

[26]