如何找到降落在曼德勃罗集主心形（周期 1 分量）边界上 p/q 根点处的参数外部射线的角度？

图像

尾迹
周期 1 大陆附近的尾迹
沿着主天线轨迹的尾迹
周期 10 的尾迹

旋转、绕数和正则星形多边形

不可约分数

首先检查 p/q 是不可约的

/*
https://stackoverflow.com/questions/19738919/gcd-function-for-c
The GCD function uses Euclid's Algorithm. 
It computes A mod B, then swaps A and B with an XOR swap.
*/
int gcd(int a, int b)
{
    int temp;
    while (b != 0)
    {
        temp = a % b;

        a = b;
        b = temp;
    }
    return a;
}


/*
 n/d -> n_new/d_new
 
*/

int give_reduced_fraction(const int n, const int d, int * n_new, int *d_new){


	int divisor = gcd(n,d);
	if (divisor != 1) {
		*n_new = n / divisor;
		*d_new = d / divisor;}
		
		else {
			*n_new = n;
         		*d_new = d;
		}
	return 0;
}

尾迹和肢体

尾迹是参数平面中由降落在主心形（周期 1 双曲分量）边界上的相同根点处的两条外部射线包围的区域。

p/q 肢体是曼德勃罗集的一部分，它包含在 p/q 尾迹内

肢体

从根点开始
以顶点结束

p/q 尾迹的外部角度

在倍增映射下具有周期 q。它与它的降落点（c = 根点）和父双曲分量的周期相同
二进制展开的周期部分的长度为 q
倍增映射下的前周期为零

p/q 尾迹的点

根是具有周期性角度的参数射线的降落点
Misiurewicz 点具有前周期外部角度

p/q 瓣的大小^[1] 是 ${\frac {1}{2^{q}-1}}$

可以通过定位天线中最小的辐条（分支）并确定其相对于主辐条的位置来识别 p/q 瓣。

尾迹、主Misiurewicz点和树枝状Julia集

来自 Wolf Jung 编写的程序 mandel 中演示 3（外部射线）第 9/12 页的笔记

角度为 1/7 和 2/7 的参数射线降落在周期 3 分量的根部，该分量是具有旋转数 1/3 的卫星型。

对于射线之间的所有参数 c 在尾迹中

对于曼德勃罗集的 1/3 肢体中的 c
- 对于尾迹的主Misiurewicz点

角度为 1/7、2/7 和 4/7 的动态射线

一起降落在排斥不动点 $z=\alpha _{c}$
临界值 z = c 位于前两条射线之间。

我们将计算 fc(z) 下 αc 的某些前像的外部角度。请注意，角度 θ 在倍增模 1 下有两个前像，θ/2 和 (θ+1)/2。

$z=-\alpha _{c}$ 是 $z=\alpha _{c}$ 的唯一前像，不同于不动点本身。角度 1/7 的前像是 (1/7)/2 = 1/14 和 (1/7 + 1)/2 = 4/7。后一个角度属于 $z=\alpha _{c}$ ，所以 1/14 是 $z=-\alpha _{c}$ 的一个外部角度。以同样的方式，得到其他角度 9/14 和 11/14。射线以蓝色绘制。将 z 移动到 $z=-\alpha _{c}$ 的前像，位于角度 2/7 和 4/7 的射线之间。角度 1/14 的前像是 (1/14)/2 = 1/28 和 (1/14 + 1)/2 = 15/28。只有后一个角度在所选区间内。z 的另外两个外部角度是 9/28 和 11/28。射线以洋红色绘制。现在 z 是位于角度 1/7 和 2/7 的射线之间的前像。通过在这个区间内取前像，得到外部角度 9/56、11/56 和 15/56。射线以红色绘制。具有前周期角度（即偶数分母）的射线降落在动力平面上具有前周期的点，或参数平面上具有 Misiurewicz 点。对于这些参数，临界值在 fc(z) 的迭代下具有前周期性。

如何计算尾迹的角度？

Mandel 程序第 4 页第 1 页的算法：当给出中心参数 c 时，从 Hubbard 树中读出角度。
- 绘制填充的 Julia 集 Kc（参数 c 是此双曲分量的中心）
- 定位 $\mp \beta _{c}$ （角度 0 和 1/2 落在不动点 $\beta _{c}$ 及其原像 $-\beta _{c}$ ）并
- 找到通往 5 周期点的两个通路
- 跟踪这些通路，并根据 Julia 集的上下侧记录数字 0 或 1。这两条射线之间的上部动态射线具有 0 到 1/2 之间的角度，第一个二进制位是 0。下部的角度在 1/2 到 1 之间，第一个位是 1。
- 你可能需要仔细放大子集。或者使用反向蜘蛛算法。
来自 Mandel 程序尾迹的角度 - 代码
组合算法 = Devaney 方法

动态平面的分区：^[2]

在揉捏序列定义中使用的分区：将开单位圆盘分为两部分： $\theta /2$ $\theta /2$ 和 $(\theta +1)/2$ $(\theta +1)/2$ （角度翻倍映射的反像）；
- 包含角度 0 的开部分标记为 0
- 另一个开部分标记为 1
- 边界标记为 ⋆

组合算法 = Devaney 方法

Devaney 方法^[3] 用于查找主芽的外部角度^[4]^[5]

步骤

从有理数旋转角度开始，
旋转角度在圆映射下的轨道
将轨道转换为行程
将行程转换为具有重复二进制小数的二进制展开式
将二进制展开式转换为二进制小数
转换为十进制小数

输入：有理数旋转角度

输出：外部角度（十进制或二进制小数）

代码

C++

以下是来自 Wolf Jung 的 Mandel 程序的 C++ 代码

// mndcombi.cpp  by Wolf Jung (C) 2007-2015, part of Mandel 5.13, 
qulonglong mndAngle::wake(int k, int r, qulonglong &n)
{  if (k <= 0 || k >= r || r > 64) return 0LL;
   qulonglong d = 1LL; 
   int j, s = 0; 
   n = 1LL;

   for (j = 1; j < r; j++)
   {  s -= k; if (s < 0) s += r; if (!s) return 0LL;
      if (s > r - k) n += d << j;
   }
   //
   d <<= (r - 1); d--; d <<= 1; d++; //2^r - 1 for r <= 64
   return d;
}

C GMP 和 MPFR

/*

------- Git -----------------
cd existing_folder
git init
git remote add origin [email protected]:adammajewski/wake_gmp.git
git add .
git commit -m ""
git push -u origin master
-------------------------------

?? http://stackoverflow.com/questions/2380415/how-to-cut-a-mpz-t-into-two-parts-using-gmp-lib-on-c

   
   to compile from console:
   gcc w.c -lgmp -lmpfr -Wall

    to run from console :

   ./a.out

   tested on Ubuntu 14.04 LTS

uiIADenominator = 89 
Using MPFR-3.1.2-p3 with GMP-5.1.3 with precision = 200 bits 
internal angle = 34/89
first external angle : 
period = denominator of internal angle = 89
external angle as a decimal fraction = 179622968672387565806504265/618970019642690137449562111 = 179622968672387565806504265 /( 2^89 - 1) 
External Angle as a floating point decimal number =  2.9019655713870868535821260055542440298749779423213948304299730531995503353103626302473331181359966368582651105245850405837027542373052381532777325121338632071561064451614697645709384232759475708007812e-1
external angle as a binary rational (string) : 1001010010010100101001001010010010100101001001010010100100101001001010010100100101001001/11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 
external angle as a binary floating number in exponential form =0.10010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001*2^-1
external angle as a binary floating number in periodic form =0.(01001010010010100101001001010010010100101001001010010100100101001001010010100100101001001)

                                                             .(01001010010010100101001001010010010100101001001010010100100101001001010010100100101001001)

*/

#include <stdlib.h> // malloc
#include <stdio.h>
#include <gmp.h>  // for rational numbers 
#include <mpfr.h> // for floating point mumbers

 // rotation map 
//the number  n  is always increased by n0 modulo d

// input :  op = n/d ( rational number ) and n0 ( integer)
//  n = (n + n0 ) % d
// d = d
// output = rop = n/d
void mpq_rotation(mpq_t rop, const mpq_t op, const mpz_t n0)
{
  
  mpz_t n; // numerator
  mpz_t d; // denominator
  mpz_inits( n, d, NULL);

 
  //  
  mpq_get_num (n, op); // 
  mpq_get_den (d, op);
  
 
  // n = (n + n0 ) % d
  mpz_add(n, n, n0); 
  mpz_mod( n, n, d);
  
      
  // output
  mpq_set_num(rop, n);
  mpq_set_den(rop, d);
    
  mpz_clears( n, d, NULL);

}

void mpq_wake(mpq_t rop, mpq_t op)
{
   
  // arbitrary precision variables from GMP library
   mpz_t  n0 ; // numerator of q
   mpz_t  nc;
   mpz_t  n;
   mpz_t  d ; // denominator of q
   mpz_t  m; // 2^i

   mpz_t  num ; // numerator of rop
   mpz_t  den ; // denominator of rop
   long long int i;
   unsigned long int base = 2;
   unsigned long int id;
   int cmp;

   mpz_inits(n, n0,nc,d,num,den,m, NULL);

   mpq_get_num(n0,op);
   mpq_get_den(d,op);
   id = mpz_get_ui(d);
   //  if (n <= 0 || n >= d ) error !!!! bad input
   mpz_sub(nc, d, n0); // nc = d - n0
   mpz_set(n, n0);   
   mpz_set_ui(num, 0);

   // rop  
    // num = numerator(rop)
    
   
   // denominator = den(rop) = (2^i) -1 
   mpz_ui_pow_ui(den, base, id) ;  // den = base^id
   mpz_sub_ui(den, den, 1);   // den = den-1
   
  // numerator   
     for (i=0; i<id ; i++){  
       
       mpz_set_ui(m, 0);
       cmp = mpz_cmp(n,nc);// Compare op1 and op2. Return a positive value if op1 > op2, zero if op1 = op2, or a negative value if op1 < op2.
       if ( cmp>0 ) {
          mpz_ui_pow_ui(m, 2, id-i-1); // m = 2^(id-i   )
          mpz_add(num, num, m); // num = num + m
          if (mpz_cmp(num, den) >0) mpz_mod( num, num, den); // num = num % d ; if num==d gives 0
          //gmp_printf("s = 1");

           }
        // else gmp_printf("s = 0");
       //gmp_printf (" i = %ld internal angle = %Zd / %Zd ea = %Zd / %Zd ; m = %Zd \n", i, n, d, num, den, m);

        // n = (n + n0 ) % d = rotation 
       mpz_add(n, n, n0); 
       if (mpz_cmp(n, d)>0) mpz_mod( n, n, d);
       //
       
          
        // 
      }

    
   // rop = external angle 
   mpq_set_num(rop,num);
   mpq_set_den(rop,den);
   mpq_canonicalize (rop); // It is the responsibility of the user to canonicalize the assigned variable before any arithmetic operations are performed on that variable.

    
   // clear memory
   mpz_clears(n, n0, nc, d, num,den, m, NULL);

}

/*

http://stackoverflow.com/questions/9895216/remove-character-from-string-in-c

"The idea is to keep a separate read and write pointers (pr for reading and pw for writing), 
always advance the reading pointer, and advance the writing pointer only when it's not pointing to a given character."

modified

 remove first length2rmv chars and after that take only length2stay chars from input string
 output = input string 
*/
void extract_str(char* str, unsigned int length2rmv, unsigned long int length2stay) {
    // separate read and write pointers 
    char *pr = str; // read pointer
    char *pw = str; // write pointer
    int i =0; // index

    while (*pr) {
        if (i>length2rmv-1 && i <length2rmv+length2stay)
          pw += 1; // advance the writing pointer only when 
        pr += 1;  // always advance the reading pointer
        *pw = *pr;    
        i +=1;
    }
    *pw = '\0';
}

int main ()
{	

	

         // notation : 
        //number type : s = string ; q = rational ; z = integer, f = floating point
        // base : b = binary ; d = decimal

        
        char *sqdInternalAngle = "13/34";
        mpq_t qdInternalAngle;   // internal angle = rational number q = n/d
        mpz_t den;  
        unsigned long int uiIADenominator;
        
       
        mpq_t  qdExternalAngle;   // rational number q = n/d
        char  *sqbExternalAngle;
        mpfr_t  fdExternalAngle ;  // 
        char  *sfbExternalAngle; // 
        
        mp_exp_t exponent ; // holds the exponent for the result string
        mpz_t zdEANumerator;
        mpz_t zdEADenominator;
        mpfr_t EANumerator;
        mpfr_t EADenominator;
        mpfr_prec_t p = 200; // in bits , should be > denominator of internal angle

         mpfr_set_default_prec (p); // but previously initialized variables are unaffected.
        //mpfr_set_default_prec (precision);

        // init variables 
        //mpf_init(fdExternalAngle);
        mpz_inits(den, zdEANumerator,zdEADenominator, NULL);
        mpq_inits (qdExternalAngle, qdInternalAngle, NULL); //
        mpfr_inits(fdExternalAngle, EANumerator, EADenominator, NULL);

        // set variables
        mpq_set_str(qdInternalAngle, sqdInternalAngle, 10); // string is an internal angle
        mpq_canonicalize (qdInternalAngle); // It is the responsibility of the user to canonicalize the assigned variable before any arithmetic operations are performed on that variable.
        mpq_get_den(den,qdInternalAngle); 
        uiIADenominator = mpz_get_ui(den);
        printf("uiIADenominator = %lu \n", uiIADenominator);

        if ( p < uiIADenominator) printf("increase precision !!!!\n");         
        mpfr_printf("Using MPFR-%s with GMP-%s with precision = %u bits \n", mpfr_version, gmp_version, (unsigned int) p);

        //        
        mpq_wake(qdExternalAngle, qdInternalAngle); // internal -> external

        mpq_get_num(zdEANumerator  ,qdExternalAngle);
        mpq_get_den(zdEADenominator,qdExternalAngle); 
        // conversions
        mpfr_set_z (EANumerator,   zdEANumerator,   GMP_RNDN);
        mpfr_set_z (EADenominator, zdEADenominator, GMP_RNDN);

        sqbExternalAngle = mpq_get_str (NULL, 2, qdExternalAngle); // rational number = fraction : from decimal to binary
        
        mpfr_div (fdExternalAngle, EANumerator, EADenominator, GMP_RNDN);

        sfbExternalAngle = (char*)malloc((sizeof(char) * uiIADenominator*2*4) + 3);
        // mpfr_get_str (char *str, mpfr_exp_t *expptr, int b, size_t n, mpfr_t op, mpfr_rnd_t rnd)
        if (sfbExternalAngle==NULL ) {printf("sfbExternalAngle error \n"); return 1;}
        mpfr_get_str(sfbExternalAngle, &exponent, 2,200, fdExternalAngle, GMP_RNDN);

        // print
        gmp_printf ("internal angle = %Qd\n", qdInternalAngle); // 
        printf("first external angle : \n");
        gmp_printf ("period = denominator of internal angle = %Zd\n", den); //

        gmp_printf ("external angle as a decimal fraction = %Qd = %Zd /( 2^%Zd - 1) \n", qdExternalAngle, zdEANumerator, den); // 
        printf ("External Angle as a floating point decimal number =  ");
        mpfr_out_str (stdout, 10, p, fdExternalAngle, MPFR_RNDD); putchar ('\n');
        gmp_printf ("external angle as a binary rational (string) : %s \n", sqbExternalAngle); // 
        
        printf ("external angle as a binary floating number in exponential form =0.%s*%d^%ld\n", sfbExternalAngle, 2, exponent); 
        extract_str(sfbExternalAngle,  uiIADenominator+exponent, uiIADenominator); 
        printf ("external angle as a binary floating number in periodic form =0.(%s)\n", sfbExternalAngle);

        // clear memory
        //mpf_clear(fdExternalAngle);
        mpq_clears(qdExternalAngle, qdInternalAngle, NULL);
        mpz_clears(den, zdEANumerator, zdEADenominator, NULL);
        mpfr_clears(fdExternalAngle, EANumerator, EADenominator, NULL);
        free(sfbExternalAngle);

        return 0;
}

haskell

Claude Heiland-Allen 的代码和描述^[6]

Mandelbrot 网页界面

主球周期为 $1$ 的心形的子球在内部角度 ${\frac {p}{q}}$ 处具有外部角度

[(.{\overline {b_{0}b_{1}\ldots b_{q-3}01}},.{\overline {b_{0}b_{1}\ldots b_{q-3}10}})]

其中

[b_{0}b_{1}\ldots =\operatorname {map} \left(\in \left(1-{\frac {p}{q}},1\right)\right)\circ \operatorname {iterate} \left(+{\frac {p}{q}}\right)\${\frac {p}{q}}]

import Data.Fixed (mod')
import Data.List (genericTake)
import Data.Ratio (denominator)

type InternalAngle = Rational
type ExternalAngle = ([Bool], [Bool])

primaryBulb
  :: InternalAngle
  -> (ExternalAngle, ExternalAngle)
primaryBulb pq
  = ( ([], bs ++ [False, True])
    , ([], bs ++ [True, False])
    )
  where
    q = denominator pq
    bs
      = genericTake (q - 2)
      . map (\x -> 1 - pq < x && x < 1)
      . iterate (\x -> (x + pq) `mod'` 1)
      $ pq

示例

可以使用以下方法检查结果

1/2

主心形区域的 1/2 醒点由角度为以下值的参数射线界定

1/3 = p01 = 0.(01)
2/3 = p10 = 0.(10)

The 1/2-wake of the main cardioid is bounded by the parameter rays with the angles 1/3  or  p01  and 2/3  or  p10 .

The angle  1/3  or  p01 has  preperiod = 0  and  period = 2. 
The conjugate angle is  2/3  or  p10 . 
The kneading sequence is  A*  and the internal address is  1-2 .
The corresponding parameter rays land at the root of a satellite component of period 2. It bifurcates from period 1.

重要点

周期 1 和 2 之间的根点 = c = -0.75 = -3/4 = 内部角度 1/2 的分叉点。2 个外部射线 1/3 和 2/3 的着陆点
周期 2 分量的中心 c = -1
主天线的顶点 c = -2 = $M_{1,1}$ . 它是角度为 $0.01={\frac {1}{2}}=0.5$ 的外部射线的着陆点

1/3

有理角度 3/7 的轨道（以及在子区间的定位）

 1 / 3  = 0 
 2 / 3  = 0 
 0 / 3  = 1

因此行程 = 001

first external angle  = 001 = 1 / 7

主心形区域的 1/3 醒点由角度为以下值的参数射线界定

1/7 = p001 = 0.(001)
2/7 = p010 = 0.(010)

注意

1/7 = 0.(142857)= 0.1428571428571428571428571428571428571428571428571428571428571428571428571428571428571428571428571428571428571428...

但小数展开在这里并不重要。只有小数比率和二进制浮点数很重要

${\begin{cases}0.(s_{-})=0.(001)_{2}={\frac {1}{7}}=0.(142857)_{10}=wake\\0.(s_{+})=0.(010)_{2}={\frac {2}{7}}=0.(285714)=wake\\\end{cases}}$

1/4

主心形区域的 1/4 醒点由角度为以下值的参数射线界定

1/15 或 p0001 或 $0.(0001)$
2/15 或 p0010 或 $0.(0010)$

n/5

有 4 个周期为 5 的醒点

1/5
2/5
3/5
4/5

主心形区域的 1/5 醒点由角度为以下值的参数射线界定

1/31 = p00001 = 0.(00001)
2/31 = p00010 = 0.(00010)

主心形区域的 4/5 醒点由角度为以下值的参数射线界定

29/31 = p11101 = 0.(11101)
30/31 = p11110 = 0.(11110)

3/7

将区间（圆）

 $I={\big (}0,1{\big ]}$

分为 2 个子区间（下部分区）

 $I_{0}={\big (}{\tfrac {0}{7}},{\tfrac {4}{7}}{\big ]}$

 $I_{1}={\big (}{\tfrac {4}{7}},{\tfrac {7}{7}}{\big ]}$

有理角度 3/7 的轨道（以及在子区间的定位）

因此，行程是

  $0101001$

可以将其转换为数字

$0101001\to 0.(0101001)_{2}={\frac {0101001}{1111111}}_{2}={\frac {41}{127}}_{10}$

主心形区域的 3/7 醒点由角度为以下值的参数射线界定

41/127 = p0101001 = 0.(0101001)
42/127 = p0101010 = 0.(0101010)

根点

 c = -0.606356884415893  +0.412399740175787 i

使用此程序（指数 = 7，mpz_init_set_ui(n, 41)）计算 41/127 在模 1 倍增映射下的轨道

5/11

ghci
GHCi, version 8.10.7: https://www.haskell.org/ghc/  :? for help
Prelude> :l bh.hs
[1 of 1] Compiling Main             ( bh.hs, interpreted )
Ok, one module loaded.
*Main> :main 5 11
internal angle p/q = 5 / 11
internal angle in lowest terms = 
5 % 11
rays of the bulb:
(01010101001) = 681 % 2047
(01010101010) = 682 % 2047

主心形区域的 5/11 醒点由角度为以下值的参数射线界定

681/2047 = p01010101001 = 0.(01010101001)
682/2047 = p01010101010 = 0.(01010101010)

周期 11 的中心：c = -0.697838195122425 +0.279304134101366 i 根点（键）：c = -0.690059870015044 +0.276026482784614 i

角度内部地址： $1\xrightarrow {5/11} 11$

n/17

主心形区域的 1/17 醒点由角度为以下值的参数射线界定

1/131071 = p00000000000000001 = 0.(00000000000000001)
2/131071 = p00000000000000010 = .(00000000000000010)

10/21

参数平面

根点 c = -0.733308614559099 +0.148209926690813 i
主心形区域的 10/21 醒点由角度为以下值的参数射线界定
- 699049/2097151 或 p010101010101010101001
- 699050/2097151 或 p010101010101010101010

动力学平面

醒点的外部射线不界定临界扇区
- 699049/2097151 或 p010101010101010101001
- 699050/2097151 或 p010101010101010101010
alpha 固定点（周期 1）z = -0.494415413112564 +0.074521133088087i

1/25

uiIADenominator = 25 
Using MPFR-3.1.5 with GMP-6.1.1 with precision = 200 bits 
internal angle = 1/25
first external angle : 
period = denominator of internal angle = 25
external angle as a decimal fraction = 1/33554431 = 1 /( 2^25 - 1) 
External Angle as a floating point decimal number =  2.9802323275873758669905622896719661257256902970579355078320375103410059138021557873907862143745145987726127630324761942815747600646073471636075786857847163330961076713939572483194617724677755177253857e-8
external angle as a binary rational (string) : 1/1111111111111111111111111 
external angle as a binary floating number in exponential form =0.10000000000000000000000001000000000000000000000000100000000000000000000000010000000000000000000000001000000000000000000000000100000000000000000000000010000000000000000000000001000000000000000000000001*2^-24
external angle as a binary floating number in periodic form =0.(0000000000000000000000001)

因此，主心形区域的 1/25 醒点由角度为以下值的参数射线界定

0.0000000298 = 1/33554431 = 1 /( 2^25 - 1) = 0.(0000000000000000000000001)
0,0000000596 = 2/33554431 = 2 /( 2^25 - 1) = 0.(0000000000000000000000010)

可以使用 Mandel 进行检查

The angle  1/33554431  or  p0000000000000000000000001
has  preperiod = 0  and  period = 25.
The conjugate angle is  2/33554431  or  p0000000000000000000000010 .
The kneading sequence is  AAAAAAAAAAAAAAAAAAAAAAAA*  and
the internal address is  1-25 .
The corresponding parameter rays are landing at the root of a satellite component of period 25.
It is bifurcating from period 1.
Do you want to draw the rays and to shift c
to the corresponding center?

中心是

 c = 0.265278321904606  +0.003712059989878 i    period = 25

12/25

醒点 12/25

根点 c = -0.738203140939397 +0.124839088573366 i
主心形区域的 12/25 醒点由角度为以下值的参数射线界定
- 11184809/33554431 或 p0101010101010101010101001 且
- 11184810/33554431 或 p0101010101010101010101010 。
卫星组件 c 的中心为 -0.739829393511579 +0.125072144080321 i 周期为 25

1/31

主心形区的 1/31 尾流

由参数射线界定，参数射线的角度为
- 1/2147483647 = p0000000000000000000000000000001 = 0.(0000000000000000000000000000001)
- 2/2147483647 = p0000000000000000000000000000010 = 0.(0000000000000000000000000000010)
根点：c = 0.260025517721190 +0.002060296266000 i
中心 c = 0.260025517721190 +0.002060296266000 i
主要 Misiurewicz 点 c = 0.259995759918769 +0.001610271381965*i
- 具有前周期 = 31，周期 = 1
- 是 31 条外部射线的着陆点
  - 2147483649/4611686016279904256 = 0000000000000000000000000000001p0000000000000000000000000000010 = .0000000000000000000000000000001(0000000000000000000000000000010)
最大的婴儿 Mandelbrot 集具有 kneading 序列 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB*，对应于内部地址 1-31-32。周期为 32。最小的角度为 3/4294967295 = 0.(00000000000000000000000000000011) 和 4/4294967295 = 0.(00000000000000000000000000000100)

在动力学平面

角度

13/34

主心形区的 13/34 尾流由参数射线界定，参数射线的角度为

4985538889/17179869183 = p0100101001001010010100100101001001 = 0.(0100101001001010010100100101001001)
4985538890/17179869183 = p0100101001001010010100100101001010 = 0.(0100101001001010010100100101001010)

 s = 0 i = 0 internal angle = 13 / 34 ea = 0 / 17179869183 ; m = 0 
s = 1 i = 1 internal angle = 26 / 34 ea = 4294967296 / 17179869183 ; m = 4294967296 
s = 0 i = 2 internal angle = 5 / 34 ea = 4294967296 / 17179869183 ; m = 0 
s = 0 i = 3 internal angle = 18 / 34 ea = 4294967296 / 17179869183 ; m = 0 
s = 1 i = 4 internal angle = 31 / 34 ea = 4831838208 / 17179869183 ; m = 536870912 
s = 0 i = 5 internal angle = 10 / 34 ea = 4831838208 / 17179869183 ; m = 0 
s = 1 i = 6 internal angle = 23 / 34 ea = 4966055936 / 17179869183 ; m = 134217728 
s = 0 i = 7 internal angle = 2 / 34 ea = 4966055936 / 17179869183 ; m = 0 
s = 0 i = 8 internal angle = 15 / 34 ea = 4966055936 / 17179869183 ; m = 0 
s = 1 i = 9 internal angle = 28 / 34 ea = 4982833152 / 17179869183 ; m = 16777216 
s = 0 i = 10 internal angle = 7 / 34 ea = 4982833152 / 17179869183 ; m = 0 
s = 0 i = 11 internal angle = 20 / 34 ea = 4982833152 / 17179869183 ; m = 0 
s = 1 i = 12 internal angle = 33 / 34 ea = 4984930304 / 17179869183 ; m = 2097152 
s = 0 i = 13 internal angle = 12 / 34 ea = 4984930304 / 17179869183 ; m = 0 
s = 1 i = 14 internal angle = 25 / 34 ea = 4985454592 / 17179869183 ; m = 524288 
s = 0 i = 15 internal angle = 4 / 34 ea = 4985454592 / 17179869183 ; m = 0 
s = 0 i = 16 internal angle = 17 / 34 ea = 4985454592 / 17179869183 ; m = 0 
s = 1 i = 17 internal angle = 30 / 34 ea = 4985520128 / 17179869183 ; m = 65536 
s = 0 i = 18 internal angle = 9 / 34 ea = 4985520128 / 17179869183 ; m = 0 
s = 1 i = 19 internal angle = 22 / 34 ea = 4985536512 / 17179869183 ; m = 16384 
s = 0 i = 20 internal angle = 1 / 34 ea = 4985536512 / 17179869183 ; m = 0 
s = 0 i = 21 internal angle = 14 / 34 ea = 4985536512 / 17179869183 ; m = 0 
s = 1 i = 22 internal angle = 27 / 34 ea = 4985538560 / 17179869183 ; m = 2048 
s = 0 i = 23 internal angle = 6 / 34 ea = 4985538560 / 17179869183 ; m = 0 
s = 0 i = 24 internal angle = 19 / 34 ea = 4985538560 / 17179869183 ; m = 0 
s = 1 i = 25 internal angle = 32 / 34 ea = 4985538816 / 17179869183 ; m = 256 
s = 0 i = 26 internal angle = 11 / 34 ea = 4985538816 / 17179869183 ; m = 0 
s = 1 i = 27 internal angle = 24 / 34 ea = 4985538880 / 17179869183 ; m = 64 
s = 0 i = 28 internal angle = 3 / 34 ea = 4985538880 / 17179869183 ; m = 0 
s = 0 i = 29 internal angle = 16 / 34 ea = 4985538880 / 17179869183 ; m = 0 
s = 1 i = 30 internal angle = 29 / 34 ea = 4985538888 / 17179869183 ; m = 8 
s = 0 i = 31 internal angle = 8 / 34 ea = 4985538888 / 17179869183 ; m = 0 
s = 0 i = 32 internal angle = 21 / 34 ea = 4985538888 / 17179869183 ; m = 0 
s = 1 i = 33 internal angle = 34 / 34 ea = 4985538889 / 17179869183 ; m = 1 
internal angle = 13/34
period = denominator of internal angle = 34
external angle as a decimal fraction = 4985538889/17179869183 = 4985538889 /( 2^34 - 1) 
external angle as a binary rational (string) : 100101001001010010100100101001001/1111111111111111111111111111111111 
external angle as a binary floating number in exponential form =0.1001010010010100101001001010010010100101001001010010100100101001*2^-1
external angle as a binary floating number in periodic form =0.(0100101001001010010100100101001)

34/89

Using GMP-5.1.3 with precision = 256 bits 
internal angle = 34/89
period = denominator of internal angle = 89
external angle as a decimal fraction = 179622968672387565806504265/618970019642690137449562111
external angle as a binary rational (string) : 1001010010010100101001001010010010100101001001010010100100101001001010010100100101001001/11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 
external angle as a binary floating number in exponential form =0.10010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010010100101*2^-1
external angle as a binary floating number in periodic form =0.(01001010010010100101001001010010010100101001001010010100100101001001010010100100101001001)

1/128

uiIADenominator = 128 
Using MPFR-4.0.2 with GMP-6.2.0 with precision = 200 bits 
internal angle = 1/128
first external angle : 
period = denominator of internal angle = 128
external angle as a decimal fraction = 1/340282366920938463463374607431768211455 = 1 /( 2^128 - 1) 
External Angle as a floating point decimal number =  2.9387358770557187699218413430556141945553000604853132483972656175588435482079339324933425313850237034701685918031624270579715075034722882265605472939461496635969950989468319466936530037770580747746862e-39
external angle as a binary rational (string) : 1/11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 
external angle as a binary floating number in exponential form =0.10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000*2^-127
external angle as a binary floating number in periodic form =0.(00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001)

89/268

Using GMP-5.1.3 with precision = 320 bits 
internal angle = 89/268
period = denominator of internal angle = 268
external angle as a decimal fraction = 67754913930863876636420964942226524366713408170066250043659752013773168429311121/474284397516047136454946754595585670566993857190463750305618264096412179005177855
external angle as a binary rational (string) : 0010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010001
/1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 
external angle as a binary floating number in exponential form =0.10010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010001
001001001001001001001001001001001001001001001001001001*2^-2
external angle as a binary floating number in periodic form =
0.(0010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010001)

G Pastor 给出了一个 IEEE 754 分辨率不足以表示的外部射线示例 ^[7]

$\theta _{268}^{-}=0.((001)^{88}0001)_{2}={\frac {67754913930863876636420964942226524366713408170066250043659752013773168429311121}{474284397516047136454946754595585670566993857190463750305618264096412179005177855}}$

$\theta _{268}^{+}=0.((001)^{88}0010)_{2}={\frac {67754913930863876636420964942226524366713408170066250043659752013773168429311122}{474284397516047136454946754595585670566993857190463750305618264096412179005177855}}$

根列表

另请参阅

参考文献

复二次多项式中的分叉和一些涉及 Mandelbrot 集瓣几何图形的民间定理，作者 Monzu Ara Begum

[1] Mandelbrot 集和 Farey 树。美国数学月刊 106 (1999), 289-302。

[2] Mandelbrot 集的有理参数射线，作者 Dierk Schleicher

[3] Mandelbrot 集和 Farey 树，作者 Robert L. Devaney

[4] Mandelbrot 集中的外部角度：Douady 和 Hubbard 的工作，作者 Douglas C. Ravenel

[5] 复数和 Mandelbrot 集，作者 Dusa McDuff 和 Melkana Brakalova

[6] -primary-bulb，作者 Claude Heiland-Allen

[7] 绘制 Mandelbrot 集外部射线局限性的解决方法，M. Romera,1 G. Pastor, A. B. Orue,1 A. Martin, M.-F. Danca，和 F. Montoya

[1]

[2]

[3]

[4]

[5]

[6]

[7]