Fraktale: Ein Kontakt mit komplexen Zahlen * Fractales: Un contact avec les nombres complexes

HAve a look at http://www.fractales.org/

Remove["Global`*"]

Addition * Addition

z = a + I b

zF[a_, b_] := a + I b;
zF[3, -5]

zF[a, b]

Re[z]

Re[zF[3, -5]]

Im[zF[3, -5]]

p[z_] := Point[{Re[z], Im[z]}];
p[zF[3, -5]]

Show[
        Graphics[{
PointSize[
              0.03], 
Line[{{-1, 0}, {1, 
                  0}}], 
Line[{{0, -1}, {0, 
                  1}}], 
p[
              zF[0.3, -0.4]]
}], 
        AspectRatio -> Automatic];

zF[a, b] + zF[c, d]

zF[3, 4] + zF[5, -6]

p[(2 - 3 I) + (8 + 5  I)]

Show[
        Graphics[{
PointSize[
              0.03], 
Line[{{-1, 0}, {1, 
                  0}}], 
Line[{{0, -1}, {0, 
                  1}}], 
p[
              zF[0.3, -0.4]], 
p[
              zF[0.1, 0.2]], 
p[
              zF[0.3, -0.4] + 
                zF[0.1, 0.2]], 
Line[{{0, 
                  0}, {0.3, -0.4}, {0.4, -0.2}, {0.1, 0.2}, {0, 
                  0}, {0.4, -0.2}}]
}], 
        AspectRatio -> Automatic];

Multiplikation * Multiplication

zF[a, b]*zF[c, d]

zF[a, b]*zF[c, d] // Expand

zF[Cos[α], Sin[α]]*
      zF[Cos[β], Sin[β]]

zF[Cos[α], Sin[α]]*zF[Cos[β], Sin[β]] // 
      Expand

?Collect

Collect[x + 4  y + 5  x  y, x]

Collect[
      Expand[zF[Cos[α], Sin[α]]*
          zF[Cos[β], Sin[β]]], 
iI]

Collect[
        Expand[zF[Cos[α], Sin[α]]*
              zF[Cos[β], Sin[β]]] /. 
          I -> iI, 
iI] /. iI -> I

Cos[α + β] // TrigExpand

Sin[α + β] // TrigExpand

(Collect[
            Expand[zF[Cos[α], Sin[α]]*
                  zF[Cos[β], Sin[β]]] /. 
              I -> iI, 
iI] /. 
          iI -> I) == 
TrigExpand[
          Cos[α + β]] + 
I TrigExpand[
            Sin[α + β]]

Degree // N

(2  Pi)/360  // N

zF[Cos[30 Degree], Sin[30 Degree]]

zF[Cos[30.  Degree], Sin[30.  Degree]]

Remove[pW]

pW[r_, φ_] := 
        Evaluate[
          p[r Cos[φ Degree] + 
              r I Sin[φ Degree]]];

Show[
        Graphics[{
PointSize[
              0.03], 
Line[{{-1, 0}, {1, 
                  0}}], 
Line[{{0, -1}, {0, 
                  1}}], 
pW[1, 30], 
pW[
              1, 45], 
pW[1, 
              75], 

Evaluate[
              p[(Cos[30 Degree] + 
                      I Sin[30 Degree])*(Cos[45 Degree] + 
                      I Sin[45 Degree])]], 
Circle[{0, 
                0}, 1]

}], 
        AspectRatio -> Automatic];

Show[
        Graphics[{
PointSize[
              0.03], 
Line[{{-1, 0}, {1, 
                  0}}], 
Line[{{0, -1}, {0, 
                  1}}], 
pW[2, 30], 
pW[
              1/2, 45], 
pW[1, 
              75], 

Evaluate[
              p[2 (Cos[30 Degree] + I Sin[30 Degree])*1/
                    2 (Cos[45 Degree] + 
                      I Sin[45 Degree])]], 

Circle[{0, 0}, 1]

}], 
        AspectRatio -> Automatic];

Show[
        Graphics[{
PointSize[
              0.03], 
Line[{{-1, 0}, {1, 
                  0}}], 
Line[{{0, -1}, {0, 
                  1}}], 
pW[1/3, 30], 
pW[
              1/2, 45], 
pW[1/6, 
              75], 

Evaluate[
              p[1/3 (Cos[30 Degree] + I Sin[30 Degree])*1/
                    2 (Cos[45 Degree] + 
                      I Sin[45 Degree])]], 

Circle[{0, 0}, 1]

}], 
        AspectRatio -> Automatic];

Division - Division

1/(a +  I b)

Conjugate[3 + 4 I]

1/(3 + 4 I)

1/(Re[a] + I Re[b])

1/(Re[a] + I Re[b]) == 
      Conjugate[Re[a] + I Re[b]]/Abs[Re[a] + I Re[b]]

Refine[
      1/(a + I b), (a ∈ Reals) And  (b ∈ 
            Reals) ]

Refine[
      Conjugate[a + I b]/
        Expand[(Conjugate[a + I b] (a + I b))], (a ∈ 
            Reals) And  (b ∈ Reals) ]

Simplify[
      1/(a + I b), (a ∈ Reals) And  (b ∈ 
            Reals) ]

ComplexExpand[1/(a + I b)]

ComplexExpand[
      1/(a + I b), (a ∈ Reals) And  (b ∈ 
            Reals) ]

ComplexExpand[
        1/(a + I b), (a ∈ Reals) And  (b ∈ 
              Reals) ] // Together

Potenzen * Puissances

z = 3 + 4 I

Abs[z]

Arg[z]

Arg[z] E^(ArcTan[(4/3)])

Abs[z] E^(I ArcTan[(4/3)]) // N

Show[
        Graphics[{
PointSize[
              0.03], 
Line[{{-1, 0}, {1, 
                  0}}], 
Line[{{0, -1}, {0, 
                  1}}], 
pW[1, 30], 
pW[
              1, 45], 
pW[1, 
              75], 

Evaluate[
              p[(Cos[30 Degree] + 
                      I Sin[30 Degree])*(Cos[45 Degree] + 
                      I Sin[45 Degree])]], 

p[E^(I 30  Degree)], 
p[
              E^(I 45  Degree)], 
p[
              E^(I 75  
                    Degree)], 

Circle[{0, 0}, 
              1]

}], 
        AspectRatio -> Automatic];

5 E^(2 + 3  I)

5 E^(2 + 3  I) // N

Arg[5 E^(2 + 3  I)]

Abs[5 E^(2 + 3  I)]

(7 + 17  I)^(2 + 3  I)

(7 + 17  I)^(2 + 3  I) // N

(E^Log[(7 + 17  I)])^(2 + 3  I) // N

E^(Log[(7 + 17  I)]*(2 + 3  I)) // N

Ausflug (1) * Virée, excursion (1)

I^I  // N

f[x_] := I^x;
NestList[f, I, 6]

NestList[f, I, 6] // N

E^(-Pi/2)

E^(-Pi/2) // N

E^(Pi I)

myList = {1.0 I, 
        0.207 + 0.  I, 
        0.947 + 0.320 I, 
        0.050 + 0.602 I}

Re[myList]

Im[myList]

{Re[myList], Im[myList]}

{Re[myList], Im[myList]} // MatrixForm

Transpose[{Re[myList], Im[myList]}] // MatrixForm

\(complexListPlot[list_, options___] := 
ListPlot[
        Transpose[{Re[list], 
            Im[list]}], 
options, 
AspectRatio -> 
          Automatic, 
PlotRange -> 
          All, 
PlotStyle -> 
          PointSize[
            0.03], 
AxesLabel -> {"Re", "Im"}
]\)

complexListPlot[N[NestList[f, I, 6]]];

complexListPlot[N[NestList[f, I, 50]]];

complexListPlot[N[NestList[f, I, 50]], 
        PlotJoined -> True];

complexListPlot[N[NestList[f, I + 1, 50]], PlotJoined -> True, 
        AxesOrigin -> {0, 0}];

Table[
        complexListPlot[N[NestList[f, I + 1, n]], PlotJoined -> True, 
          AxesOrigin -> {0, 0}], {n, 1, 50}];

Ausflug (2) * Virée, excursion (2)

Remove["Global`*"]

f[x_] := (1 + I)^x;
Nest[f, 1 + I, 100] // N

a * Series[(z^e - 1)/e, {e, 0, 2}]

?FindRoot

FindRoot[I^z - z, {z, 1}]

FindRoot[I^z - z == 0, {z, 1}]

a = z /. %

a

I^a

f[z_] := I^z;  f[a]

f[z]

f[z_] := 
        Block[{a, loga}, 
loga = 
            Log[a] /. FindRoot[
                a == z^a, {a, 0.2 + 0.3  I}]; 
{Abs[
              loga], Arg[loga] 180/N[Pi]}];
f[1 + I]

f[z_] := 
        Block[{a, loga}, 
loga = 
            Log[a] /. FindRoot[
                a == 
                  z^a, {a, {0.2 + 0.3  I, 0.3 + 0, 
                    4  I}}]; 
{Abs[loga], 
            Arg[loga] 180/N[Pi]}];
f[1 + I]

f[z_] := I^z;
Abs[N[f'[z]]]

N[Arg[f'[a]]]/Degree

Plots * Plots

Remove["Global`*"]

Plot3D[
        Abs[Sin[x + y I]], {x, -Pi, Pi}, {y, -Pi, Pi}];

?Abs

Abs[Sin[x + y I]] /. {x -> 1. , y -> 1. }

?Arg

Arg[Sin[x + y I]] /. {x -> 1. , y -> 1. }

?Hue

Hue[N[Arg[Sin[1.3 + 0.4 I]]]]

Hue[N[(Pi + Arg[Sin[1.3 + 0.4 I]])/(2  Pi)]]

Plot3D[{Abs[Sin[x + y I]],   Hue[
            N[(Pi + Arg[Sin[x + y I]])/(2  
                    Pi)]]}, 
{x, -Pi, 
          Pi}, {y, -Pi, Pi}];

\(\(Plot3D[{Abs[Sin[x + y\ I]], \ \ Hue[
            N[\((Pi + Arg[Sin[x + y\ I]])\)/\((2  
                    Pi)\)]]}, 
{x, \(-Pi\), 
          Pi}, {y, \(-Pi\), 
          Pi}, 
AxesLabel -> {"Re", "Im", "Abs"}, PlotPoints -> 50];\)\)

\(\(Plot3D[{Abs[Sin[x + y\ I]], \ \ Hue[
            N[\((Pi + Arg[Sin[x + y\ I]])\)/\((2  
                    Pi)\)]]}, 
{x, \(-Pi\), 
          Pi}, {y, \(-Pi\), 
          Pi}, 
AxesLabel -> {"Re", "Im", "Abs"}, PlotPoints -> 30];\)\)

\(\(Plot3D[{Abs[Sin[x + y\ I]], \ \ Hue[
            N[\((Pi + Arg[Sin[x + y\ I]])\)/\((2  
                    Pi)\)]]}, 
{x, \(-Pi\), 
          Pi}, {y, \(-Pi\), 
          Pi}, 
AxesLabel -> {"Re", "Im", "Abs"}, PlotPoints -> 15];\)\)

complexZFarbe[z_, n_] := 
        Module[{nZ, aZ, maxZ, nPi, n2Pi}, 
nZ = 
            N[z]; 
aZ = Abs[z]; 
maxZ = 
            N[10^n]; 
nPi = 
            N[Pi]; 
n2Pi = 
            2  nPi; 
{Min[aZ, maxZ], 
            Hue[(nPi + If[nZ == 0, 0, Arg[nZ/aZ]])/
                n2Pi]}
];

\(\(Plot3D[
        complexZFarbe[x + I\ y, 30], 
{x, \(-2\), 
          2}, {y, \(-2\), 
          2}, 
AxesLabel -> {"Re", "Im", "Abs"}];\)\)

\(\(Plot3D[
        complexZFarbe[Sin[x + I\ y], 30], 
{x, \(-Pi\), 
          Pi}, {y, \(-Pi\), 
          Pi}, 
AxesLabel -> {"Re", "Im", "Abs"}];\)\)

\(\(Plot3D[
        complexZFarbe[Cos[x + I\ y], 30], 
{x, \(-Pi\), 
          Pi}, {y, \(-Pi\), 
          Pi}, 
AxesLabel -> {"Re", "Im", "Abs"}];\)\)

\(\(Plot3D[
        complexZFarbe[Sin[Sin[x + I\ y]], 
          30], 
{x, \(-Pi\), Pi}, {y, \(-Pi\), 
          Pi}, 
AxesLabel -> {"Re", "Im", "Abs"}];\)\)

\(\(Plot3D[
        complexZFarbe[Sin[Sin[x + I\ y]], 
          30], 
{x, \(-Pi\), Pi}, {y, \(-Pi\), 
          Pi}, 
AxesLabel -> {"Re", "Im", "Abs"}, PlotPoints -> 50];\)\)

f[zInt_, k_] := Nest[Sin, zInt, k];
f[z, 3]

\(\(Plot3D[
        Evaluate[
          complexZFarbe[f[x + I\ y, 3], 30]], 
{x, \(-Pi\), 
          Pi}, {y, \(-Pi\), 
          Pi}, 
AxesLabel -> {"Re", "Im", "Abs"}, PlotPoints -> 50];\)\)

\(\(Plot3D[
        Evaluate[
          complexZFarbe[f[x + I\ y, 3], 30]], 
{x, \(-Pi\), 
          Pi}, {y, \(-Pi\), 
          Pi}, 
AxesLabel -> {"Re", "Im", "Abs"}, PlotPoints -> 100, 
        PlotRange -> {0, 10^5}];\)\)

f[Pi + I Pi, 
        3]//N      (*  ! ! ! !   *)

complexZLogLogFarbe[z_] := 
        Module[{nZ, aZ, nPi, n2Pi, nE}, 
nZ = 
            N[z]; 
aZ = Abs[z]; 
nPi = 
            N[Pi]; 
n2Pi = 2  nPi; 
nE = 
            N[E]; 
{Log[Log[aZ + nE]], 
            Hue[(nPi + If[nZ == 0, 0, Arg[nZ/aZ]])/
                n2Pi]}
];

\(\(Plot3D[
        Evaluate[
          complexZLogLogFarbe[
            f[x + I\ y, 3]]], 
{x, \(-Pi\), 
          Pi}, {y, \(-Pi\), 
          Pi}, 
AxesLabel -> {"Re", "Im", "LogLogAbs"}, PlotPoints -> 100, 
        PlotRange -> All];\)\)

\(\(Plot3D[
        Evaluate[
          complexZLogLogFarbe[
            f[x + I\ y, 4]]], 
{x, \(-Pi\), 
          Pi}, {y, \(-2\), 
          2}, 
AxesLabel -> {"Re", "Im", "LogLogAbs"}, PlotPoints -> 100];\)\)

Fraktale  - Fractals

Remove["Global`*"]

anzahlSinWeg[z_, h_, mZaehler_] := 
        Module[{zaehler, nZ, hInt}, 
hInt = 
            h; 
mZaehlerInt = 
            mZaehler; 
nZ = N[z]; 
For[
            zaehler = 
              0, 
(Abs[Im[nZ]]  < 
                  hInt)  &&  (zaehler  <   mZaehlerInt), 
nZ = 
              Sin[nZ];  
++zaehler]; 
zaehler
];
anzahlCosWeg[z_, h_, mZaehler_] := 
        Module[{zaehler, nZ, hInt}, 
hInt = 
            h; 
mZaehlerInt = 
            mZaehler; 
nZ = N[z]; 
For[
            zaehler = 
              0, 
(Abs[Im[nZ]]  < 
                  hInt)  &&  (zaehler  <   mZaehlerInt), 
nZ = 
              Cos[nZ];  
++zaehler]; 
zaehler
];
anzahlQuadrWeg[c_, h_, mZaehler_] := 
        Module[{zaehler, nZ, hInt, z}, 
hInt = 
            h; 
mZaehlerInt = 
            mZaehler; 
nZ = N[c]; 
For[
            zaehler = 
              0, 
(Abs[Im[nZ]]  < 
                  hInt)  &&  (zaehler  <   mZaehlerInt), 
nZ = 
              nZ^2 + c;  
++zaehler]; 
zaehler
];
sinFractal[{{ReMin_, ReMax_}, {ImMin_, ImMax_}}, 
          schritte_] := {{{ReMin, ReMax}, {ImMin, ImMax}}, 
          Table[anzahlSinWeg[x + I y, 10000, 100], {y, ImMin, 
              ImMax, (ImMax - ImMin)/schritte}, {x, ReMin, 
              ReMax, (ReMax - ReMin)/
                schritte}]};
quadrFractal[{{ReMin_, ReMax_}, {ImMin_, ImMax_}}, schritte_, h_, 
          mZaehler_] := {{{ReMin, ReMax}, {ImMin, ImMax}}, 
          Table[anzahlQuadrWeg[x + I y, h, mZaehler], {y, ImMin, 
              ImMax, (ImMax - ImMin)/schritte}, {x, ReMin, 
              ReMax, (ReMax - ReMin)/
                schritte}]};
sFracPlot[{{xMin_, xMax_}, {yMin_, yMax_}}, n_] := 
        ListDensityPlot[(sinFractal[{{xMin, xMax}, {yMin, yMax}}, 
                n])[[2]]];
sFracPlotM[{{xMin_, xMax_}, {yMin_, yMax_}}, n_] := 
        ListDensityPlot[(sinFractal[{{xMin, xMax}, {yMin, yMax}}, 
                n])[[2]], 
          Mesh  ->  False];
quadrFracPlotM[{{xMin_, xMax_}, {yMin_, yMax_}}, n_, h_, mZaehler_] := 
        ListDensityPlot[(quadrFractal[{{xMin, xMax}, {yMin, yMax}}, n, h, 
                mZaehler])[[2]], Mesh  ->  False];

anzahlSinWeg[2 + I 2, 10000, 1000]

anzahlSinWeg[-1 + I 2, 10000, 100]

Table[anzahlSinWeg[3 + I y/50, 10000, 100], {y, 0, 100}]

\(\(Plot3D[
        anzahlSinWeg[x + I\ y, 10000, 100], 
{x, \(-Pi\), 
          Pi}, {y, \(-Pi\), 
          Pi}, 
AxesLabel -> {"Re", "Im", "anzahlSinWeg"}, PlotPoints -> 100, 
        PlotRange -> {0, 100}];\)\)

\(\(Plot3D[
        Evaluate[
          anzahlSinWeg[x + I\ y, 10000, 
            100]], 
{x, \(-Pi\), Pi}, {y, \(-Pi\), 
          Pi}, 
AxesLabel -> {"Re", "Im", "anzahlSinWeg"}, PlotPoints -> 100, 
        PlotRange -> {0, 100}];\)\)

Plot3D[
        anzahlSinWeg[x + I y, 10000, 100], 
{x, -2 Pi, 
          2  Pi}, {y, -2 Pi, 
          2  Pi}, 
AxesLabel -> {"Re", "Im", "\
anzahlSinWeg"}, PlotPoints -> 100, 
        PlotRange -> {0, 100}];

Plot3D[
        anzahlCosWeg[x + I y, 10000, 100], 
{x, -2 Pi, 
          2  Pi}, {y, -2 Pi, 
          2  Pi}, 
AxesLabel -> {"Re", "Im", "\
anzahlSinWeg"}, PlotPoints -> 100, 
        PlotRange -> {0, 100}];

DensityPlot[
        anzahlSinWeg[x + I y, 10000, 100], 
{x, -2 Pi, 
          2  Pi}, {y, -2 Pi, 
          2  Pi}, 
AxesLabel -> {"Re", "Im", "\
anzahlSinWeg"}, PlotPoints -> 100];

DensityPlot[
        anzahlCosWeg[x + I y, 10000, 100], 
{x, -2 Pi, 
          2  Pi}, {y, -2 Pi, 
          2  Pi}, 
AxesLabel -> {"Re", "Im", "\
anzahlSinWeg"}, PlotPoints -> 100];

DensityPlot[
        anzahlSinWeg[x + I y, 10000, 100], 
{x, -2 Pi, 
          2  Pi}, {y, -2 Pi, 
          2  Pi}, 
AxesLabel -> {"Re", "Im", "\
anzahlSinWeg"}, PlotPoints -> 200];

sFrac = 
      sinFractal[{{-2 Pi, 2  Pi}, {-2 Pi, 2  Pi}}, 100]

ListDensityPlot[sFrac[[2]]];

sFracPlot[{{0, 2  Pi}, {0, 2  Pi}}, 100];

sFracPlot[{{0, Pi}, {0, 2  Pi}}, 200];

?Mesh

?ListDensityPlot

sFracPlotM[{{0, Pi/2}, {0, Pi}}, 300];

quadrFracPlotM[{{-2 Pi, 2  Pi}, {-2 Pi, 2  Pi}}, 300, 10000, 
        1000];

quadrFracPlotM[{{-Pi, 0}, {-Pi, 0}}, 300, 1000, 
        100];

quadrFracPlotM[{{-2 Pi, 2  Pi}, {-2 Pi, 2  Pi}}, 300, 2, 
        1000];

quadrFracPlotM[{{-Pi, 0}, {-Pi, 0}}, 200, 2, 
        100];

quadrFracPlotM[{{-Pi, 0}, {-Pi, 0}}, 150, 2, 
        100];

Versuch  - Essayer

Remove["Global`*"]

mandel[n_] := 
        Show[Graphics[
Map[{Point[{Re[#], Im[#]}], 
                  Point[-{Re[#], Im[#]}]} &, 
Drop[
                NestList[
                  If[Random[Integer] == 1, 1, -1] Sqrt[# - Sqrt[#]] & , 
                  0.2, n + 50 ]]] ]];

mandel[30000];

Show[
        Graphics[
Map[{Point[{Re[#], Im[#]}], 
                Point[-{Re[#], Im[#]}]} &, 
            Flatten[Table[
                Drop[NestList[
                    If[Random[Integer] == 1, 1, -1] 
                        N[Sqrt[# - Sqrt[#]]] & , a + I b, 50]], {a, -2, 
                  2, 0.025}, {b, -2, 2, 0.025}]]]]];

Show[
        Graphics[
Map[{Point[{Re[#], Im[#]}], 
                Point[-{Re[#], Im[#]}]} &, 
            Flatten[Table[
                Drop[NestList[
                    If[Random[Integer] == 1, 1, -1] 
                        N[Sqrt[# - Sqrt[#]]] & , a + I b, 50]], {a, -4, 
                  4, 0.05}, {b, -4, 4, 0.05}]]]]];

Show[
        Graphics[
Map[{Point[{Re[#], Im[#]}], 
                Point[-{Re[#], Im[#]}]} &, 
            Flatten[Table[
                Drop[NestList[
                    If[Random[Integer] == 1, 1, -1] 
                        N[Sqrt[# - Sqrt[#]]] & , a + I b, 50]], {a, -1, 
                  1, 0.012}, {b, -1, 1, 0.012}]]]]];

Julia  - Julia

Remove["Global`*"]

julia1[c_, n_] := 
        Show[Graphics[
Map[{Point[{Re[#], Im[#]}], 
                  Point[-{Re[#], Im[#]}]} &, 
Drop[
                NestList[If[Random[Integer] == 1, 1, -1] Sqrt[# - c] & , 
                  0.2, n + 50 ]]] ]];

julia1[+0.12256117 + I 0.74486177, 30000];

julia1[-0.12256117 + I 0.74486177, 30000];

julia1[0.32 + I 0.043, 30000];

julia1[0.38 - I 0.508, 30000];

julia1[0.4 - I 0.50, 30000];

julia1[0.390541 + I 0.586788, 30000];

julia2[c_, n_] := 
        Show[Graphics[
Map[{Point[{Re[#], Im[#]}], 
                  Point[{-Re[#], Im[#]}]} &, 
Drop[
                NestList[If[Random[Integer] == 1, 1, -1] Sqrt[# - c] & , 
                  0.2, n + 50 ]]] ]];

julia2[+0.12256117 + I 0.74486177, 10000];

julia2[-0.12256117 + I 0.74486177, 10000];

julia2[0.32 + I 0.0043, 30000];

julia2[0.4 - I 0.50, 30000];

Cantor  - Cantor

Remove["Global`*"]

cantor[b_, m_] := 
        Module[{i = 1, 
            potenz = 
              Map[{Re[#], Im[#]} &,  
                b^Range[m + 1]]}, 
Show[
            Graphics[
Map[Point, 
                Nest[
Join[#, # /. {x_Real, 
                            y__Real} -> {x, y} + 
                            potenz[[i++]]] &, 
{potenz[[1]]}, 
m]]], 
PlotRange -> All, Axes -> Automatic, 
            AspectRatio -> 1]];

cantor[0.8 - 0.2 I, 16];

cantor[0.0 + 0.931 I, 16];

cantor[0.5 + 0.5  I, 16];

cantor[0.2 + 0.6  I, 16];

Animate !!!

Table[cantor[0.65 - 0.3 I, k], {k, 4, 18}];

Table[cantor[1.0 - 1/k -  1.0/k I, 16], {k, 1, 30}];