Place the cursor in the cell below and press Shift+Enter to start. Answer YES to the question that follows.

Off[General::"spell", General::"spell1", Power::"infy", 
      Graphics::"gptn"]

LightRed = RGBColor[1,  .3,  .3];
\(\(\(LightBlue = RGBColor[ .3,  .3, 1];\)\(
\)
    \)\)
thinline  =  Thickness[0.002];
thickline = Thickness[0.005];

One way to use this notebook is to select the Menu item Kernel->Evaluation->Evaluate Notebook and wait until the notebook is evaluated. To look at the animations that are created below highlight the cells with pictures and press Ctrl+y. Then you can use the menu in the bottom left corner to control the animation.

A standard grid

In the next cell I define the command that will draw transformation of given grids. I hope that the examples will explain how to use my command. (Ignore the next cell and look at the examples below.)

Clear[fn, gn, z, de, xmin, xmax, ymin, ymax, xst, yst, xpts, 
        ypts];

    
Clear[ComplexStGrid, fn, xmin, xma, xst, ymin, ymax, yst, PTS, 
        opts];

    
ComplexStGrid[
          fn_, {x_Symbol, xmin_, xmax_, xst_}, {y_Symbol, ymin_, ymax_, 
            yst_}, PTS_: {100, 100}, 
          opts___Rule] := 
Module[{xpts, ypts, stx, sty, 
            pts}, 
xpts = 
            PTS[[1]]; 
          ypts = PTS[[2]]; 
Show[
Graphics[{
{thinline, LightRed, 
                  Table[
Line[
Table[{Re[
                            s + I t], Im[s + I t]}, {t, ymin, 
                          ymax, ((ymax - ymin)/ypts)}]
        ], {s, xmin, xmax, xst}]}, 
{thinline, 
                  LightBlue, 
                  Table[
Line[
Table[{Re[
                            s + I t], Im[ s + I t ]}, {s, xmin, 
                          xmax, ((xmax - xmin)/xpts)}]
        ], {t, ymin, ymax, 
                      yst}]}, 

{thickline, Red, 
                  Table[
Line[
Table[{Re[
                            fn[s + I t]], Im[fn[s + I t]]}, {t, ymin, 
                          ymax, ((ymax - ymin)/ypts)}]
        ], {s, xmin, xmax, xst}]}, 
{thickline, Blue, 
                  Table[
Line[
Table[{Re[
                            fn[s + I t]], Im[fn[s + I t]]}, {s, xmin, 
                          xmax, ((xmax - xmin)/xpts)}]
        ], {t, ymin, ymax, 
                      yst}]}
}], 
AspectRatio ->  Automatic, Frame -> True, 
            Sequence[opts]
]];

Sometimes grids do not give satisfactory results. That happens when the images of the grid lines have discontiuities. As an improvised solution for this problem in the next cell I define the command that will just plot points on the grid lines and their images.

Clear[fn, gn, z, de, xmin, xmax, ymin, ymax, xst, yst, xpts, 
        ypts];

    
Clear[ComplexStGridP, fn, xmin, xma, xst, ymin, ymax, yst, PTS, 
        opts];

    
ComplexStGridP[
          fn_, {x_Symbol, xmin_, xmax_, xst_}, {y_Symbol, ymin_, ymax_, 
            yst_}, PTS_: {100, 100}, 
          opts___Rule] := 
Module[{xpts, ypts, stx, sty, 
            pts}, 
xpts = 
            PTS[[1]]; 
          ypts = PTS[[2]]; 
Show[
Graphics[{
{PointSize[0.005], 
                  LightRed, 
Table[
 
Table[
                      Point[{Re[s + I t], Im[s + I t]}], {t, ymin, 
                        ymax, ((ymax - ymin)/ypts)}]
        , {s, xmin, xmax, xst}]}, 
{PointSize[ .005], 
                  LightBlue, 
                  Table[
 
Table[
                      Point[{Re[s + I t], Im[ s + I t ]}], {s, xmin, 
                        xmax, ((xmax - xmin)/xpts)}]
        , {t, ymin, ymax, 
                      yst}]}, 

{PointSize[0.01], Red, 
                  Table[
 
Table[
                      Point[{Re[fn[s + I t]], Im[fn[s + I t]]}], {t, ymin, 
                        ymax, ((ymax - ymin)/ypts)}]
         , {s, xmin, xmax, xst}]}, 
{PointSize[0.01], 
                  Blue, Table[
 
Table[
                      Point[{Re[fn[s + I t]], Im[fn[s + I t]]}], {s, xmin, 
                        xmax, ((xmax - xmin)/xpts)}]
       , {t, ymin, ymax, 
                      yst}]}
}], 
AspectRatio ->  Automatic, Frame -> True, 
            Sequence[opts]
]];

Here are few examples. Try your own.

ComplexStGrid[
        Function[z, z^2], {x, -1, 2,  .2}, {y, -1, 2,  .2}, {250, 
          250}, PlotRange -> All, ImageSize -> 300];

Solve[(1/2) (z - (1/z)) == w, z]

{{z -> w - (Sqrt[1 + (w^2)])}, {z -> 
          w + (Sqrt[1 + (w^2)])}}

ComplexStGrid[
        Function[w, w + (Sqrt[1 + (w^2)])], {x, -3, 3,  .2}, {y, -3, 
          3,  .2}, {150, 150}, 
        PlotRange -> {{-2, 2}, {-2, 2}}];

Solve[(1/2) (z + (1/z)) == w, z]

ComplexStGrid[
        Function[w, w + (Sqrt[-1 + (w^2)])], {x, -3, 
          3,  .2}, {y, -3, 3,  .2}, {150, 150}, 
        PlotRange -> {{-6, 6}, {-6, 6}}];

ComplexStGridP[
        Function[w, w + (Sqrt[-1 + (w^2)])], {x, -3, 
          3,  .2}, {y, -3, 3,  .2}, {50, 50}, 
        PlotRange -> {{-6, 6}, {-6, 6}}];

ComplexStGrid[
        Function[z, z^(1/2)], {x, 1/2, 2,  .1}, {y, 1/2, 2,  .1}, {150, 
          150}, PlotRange -> {{-1, 1}, {-1, 1}}];

ComplexStGrid[
      Function[z, z^3], {x,  .5, 1.5,  .2}, {y, -1.5, 1.5,  .2}, {250, 
        250}, PlotRange -> {{-7, 4}, {-7, 7}},  
      ImageSize -> 350]

ComplexStGrid[
      Function[z, Sin[z]], {x, -(Pi/2) - (Pi/6), (Pi/2) + (Pi/6), 
        (Pi/17)}, {y, -3, 3,  .1}, {250, 250}, 
      PlotRange -> {{-4, 4}, {-4, 4}},  
      ImageSize -> 350]

Solve[z + (1/z) == 2 w, z]

ComplexStGridP[
      Function[w, w + (Sqrt[-1 + (w^2)])], {x, -3, 3,  .5}, {y, -3, 
        3,  .5}, {50, 50}, PlotRange -> {{-4, 4}, {-4, 4}},  
      ImageSize -> 350]

ComplexStGrid[
      Function[w, w + (Sqrt[1 + (w^2)])], {x, -3, 3,  .2}, {y, -3, 
        3,  .2}, {250, 250}, PlotRange -> {{-7, 7}, {-7, 7}},  
      ImageSize -> 350]

The following cell will make one of the animations from the website.

Table[
        ComplexStGrid[
          Function[z, z^(k/12)], {x, -1.5, 1.5,  .2}, {y, -1.5, 
            1.5,  .2}, {250, 250}, 
          PlotRange -> {{-8, 8}, {-7, 7}}, 
          PlotLabel -> z^(k/12), ImageSize -> 350], {k, 12, 
          36}];

Reduce[Sin[z] == 2, z]

ComplexExpand[TrigToExp[π - ArcSin[2]]]

ComplexExpand[TrigToExp[ArcSin[2]]]

A polar grid

The next (long) cell defines a command to transform polar grids.

Clear[fn, gn, z, de, rmin, rmax, tmin, tmax, rst, tst, rpts, 
        tpts];

    
ComplexPoGrid[
          fn_, {r_Symbol, rmin_, rmax_, rst_}, {t_Symbol, tmin_, tmax_, 
            tst_}, PTS_: {100, 100}, 
          opts___Rule] := 
Module[{rpts, 
            tpts}, 
rpts = 
            N[PTS[[1]]]; 
          tpts = N[
              PTS[[2]]]; 
Show[
Graphics[{
{thinline, LightRed, 
                  Table[
Circle[{0, 0}, 
                      s, {tmin, tmax}], {s, rmin, rmax, 
                      rst}]}, 
{thinline, LightBlue, 
                  Table[
Line[{rmin {Cos[t], Sin[t]}, 
                        rmax {Cos[t], Sin[t]}}], {t, tmin, tmax, 
                      tst}]}, 
{thickline, Red, 
                  Table[
Line[
Table[{N[
                            Re[fn[s Exp[I t]]]], 
                          N[Im[fn[s Exp[I t]]]]}, {t, tmin, 
                          tmax, ((tmax - tmin)/N)[tpts]}]
        ], {s, rmin, rmax, rst}]}, 
{thickline, 
                  Blue, Table[
Line[
Table[{N[Re[fn[s Exp[I t]]]], N[Im[fn[s Exp[I t]]]]}, {s, rmin, 
                          rmax, ((rmax - rmin)/N)[rpts]}]
        ], {t, tmin, tmax, 
                      tst}]}
}], 
AspectRatio ->  Automatic, Frame -> True, 
            Sequence[opts]
]];

Here are some examples. Feel free to try your own examples.

ComplexPoGrid[
      Function[z, (z^2)], {r, 1, 2,  .2}, {t, -(Pi/3), (Pi/2), 
        (Pi/24)}, {200, 200}, ImageSize -> 300]

ComplexPoGrid[
      Function[z, (z^(1/2))], {r, 1, 2,  .2}, {t, -(Pi/3), (Pi/2), 
        (Pi/24)}, {200, 200}, PlotRange ->  All, 
      ImageSize -> 200]

The cell below gives an animation analogous to the one which is on the website, but with a polar grid.

Table[
        ComplexPoGrid[
          Function[z, z^(k/12)], {r, 1, 2,  .2}, {t, -(Pi/3), 
            (Pi/3), (Pi/24)}, {200, 200}, 
          PlotRange -> {{-8, 8}, {-8, 8}}, 
          ImageSize -> 300], {k, 12, 36, 1}];

In the next animation we use convex combinations of  z  and  (z^3) to generate the transition.

Table[
        ComplexPoGrid[
          Function[z, (1 - c) z  + c (z^3)], {r, 1, 
            2,  .2}, {t, -(Pi/3), (Pi/3), (Pi/24)}, {200, 200}, 
          PlotRange -> {{-8, 8}, {-8, 8}}, 
          ImageSize -> 300], {c, 0, 1,  .05}];