Bsrgvty

Beeing used to programming in C-like languages I am struggling with iterations and loops with mathematica. I am trying not to use the For command, as already lots of people recommended.

I am trying to solve the following problem:

Given the map $z_i+1= z_i^2 +c$ with $z_i, c in mathbbC$ and $z_0 = 0$ evaluate the contours that represents given the parameter $c$ the number of iterations $i$ that I have to perform in order to have $|z_i|> 2$. Perform the computation with $-0.6 leq Re(z_i)leq -0.4 $ and $0.6 leq Im(z_i)leq 0.4$ and 100 points per axis.

Given the condition I though I could use a While Loop to perform the task

i=0; (*init counter*)
z[i]=0; (*init z[i]*)
g[c_]:= While[
 Abs[z[i]]<= 2, (*condition*)
 z[i+1]= z[i]^2 +c; (*process*)
 i++; (*increment*)
]
Print[i]
g[0.2 + 0.2 I]

This computation with the input, say, $(-0.2 +0.2 i)$ (and with many others) takes all the memory of the machine I am using (Wolfram online). I don't understand whether I am just missing something or the amount of computation I can perform on the server just isn't enough (which seems really unlikely)

Furthermore I would like the function to return an integer (i - the number of iterations) but I really struggle with how to correctly use the synthax of Mathematica to do that.

Thanks in advance to everyone who is so keen to stop by and help :)

The problem with your code is that for some values of c, Abs[z] will never become larger than 2. You need to cap the number of iterations.

For this type of iteration, the typical function to use is Nest and related functions.

countIter[c_] := 
 Length@NestWhileList[
 #^2 + c &,
 0.0,
 Abs[#] <= 2 &,
 1,
 100 (* limit number of iterations to 100 *)
 ] 

result = 
 Table[
 countIter[re + im I],
 re, -0.6, -0.4, 0.2/100,
 im, 0.4, 0.6, 0.2/100
 ];

ArrayPlot[result, ColorFunction -> "Rainbow"]

However, this type of problem is quite amenable to compilation with Compile. When using Compile, the usual advice does not apply: a procedural style is still the best. (This does not mean that For is good, I'd still argue against that. But there are many other procedural constructs such as Do and While).

countIterCompiled = Compile[c, _Complex,
 Block[z = 0.0 + 0.0 I, i = 0,
 While[i <= 100 && Abs[z] <= 2,
 z = z^2 + c;
 i++
 ];
 i
 ]
 ]

Using countIterCompiled will be much faster than countIter.

For iterated function systems like this, Nest and relatives are the preferred tools. Just exploring your (rather famous) map:

f[z_, c_] := z^2 + c
Abs[NestList[f[#, 0.2 + 0.2 I] &, 0, 30]]
(* 0, 0.282843, 0.344093, 0.351367, 0.327239, 0.304778, 0.303605, 
 0.311545, 0.316158, 0.315818, 0.313773, 0.312729, 0.31295, 0.313482, 
 0.313697, 0.313611, 0.313477, 0.313435, 0.313464, 0.313497, 0.313504, 
 0.313495, 0.313487, 0.313486, 0.313489, 0.313491, 0.313491, 0.31349, 
 0.31349, 0.31349, 0.31349 *)

As you can see, it converges to a value inside your radius. That's why your function doesn't terminate.

You could also use MandelbrotSetPlot to create Szabolcs' graphic:

MandelbrotSetPlot[-0.6 + 0.4 I, -0.4 + 0.6 I, PlotLegends -> Automatic]