# Visualizing a Complex Vector Field near Poles

I've been playing around with a visualization technique for complex functions where one views the function $f: \mathbb{C} \rightarrow \mathbb{C}$ as the vector field $f: \mathbb{R^2} \rightarrow \mathbb{R^2}$. These vector fields have some nice properties as a consequence of the Cauchy-Riemann equations, and usually look pretty neat. I'm surprised I haven't heard of this until recently (they're known as Pólya plots). Here's an example:

f[z_] := Exp[-z^2]
VectorPlot[{Re[f[x + I*y]], Im[f[x + I*y]]}, {x, -1.5, 1.5}, {y, -1, 1},
VectorPoints -> Fine]


The problem I'm having is trying to do this near the poles of functions. This is understandable, however Mathematica usually has no trouble plotting functions with singularities. Here's an attempt to plot $z^{-1}$:

I tried upping MaxRecursion and a couple of other things, but I figured you guys might know what to do immediately.

Now that the pole issue has been taken care of (thanks to everyone who contributed), here are some very intriguing plots:

Poles of $\Gamma(z)$ at -4, -3, and -2:

PolyaPlot[g, {-4.5, -1.5}, {-1, 1}, 50]


$\sin(z)$:

PolyaPlot[F, {-3 Pi/2, 3 Pi/2}, {-4, 4}, 45]


Now, here is a function that has poles over a subset of the Gaussian integers. The plot immediately reveals the symmetry of the zeros of the nontrivial polynomial

$35900-(72768-72768 i) z-128304 i z^2+(64392+64392 i) z^3-40305 z^4+(8064-8064 i) z^5+2016 i z^6-(144+144 i) z^7+9 z^8$

$\displaystyle \sum_{m=1}^{3} \sum_{n=1}^{3} \frac{1}{z-(m+in)}$:

PolyaPlot[G, {.7,3.3},{.7,3.3},60]


where the function PolyaPlot is given by:

PolyaPlot[f_,ReBounds_,ImBounds_,vPoints_]:=Module[{reMin=ReBounds[[1]],reMax=ReBounds[[2]],imMin=ImBounds[[1]],imMax=ImBounds[[2]]},
Return[VectorPlot[{Re[f[x+I*y]],Im[f[x+I*y]]},{x,reMin,reMax},{y,imMin,imMax},
VectorPoints->vPoints,VectorScale->{Automatic,Automatic,None},VectorColorFunction -> (Hue[2 ArcTan[#5]/Pi] &),VectorColorFunctionScaling->False]];
]

-
Isn't the Pólya vector field the complex conjugate of the function? This lends itself to look at things like computing the flux out of an area through a contour integral (effectively using Gauss theorem). Code Example at MathWorld –  Thies Heidecke Apr 16 '12 at 9:15
Indeed, these aren't quite Pólya plots but I was trying to get a direct visualization of the function. Using the conjugate makes a lot more sense when you want to find a convenient path $\gamma(t)$ such that $\gamma '(t) = f(\gamma(t))^{*}$, so performing a contour integral reduces to $\int_{\gamma} |f(\gamma(t))|^{2}$. Turning these plots into honest Pólya plots is a matter of a negative sign. –  Jackson Walters Apr 16 '12 at 14:53
Have you tried looking at the StreamPlots of these functions? They're even prettier! –  Rahul Nov 3 '12 at 10:52

Here are two suggestions for the function

f[z_] := 1/z;


First, instead of defining a region to omit from your plot, you should base the omission criterion on the length of the vectors (so that you don't have to adjust the criterion manually when switching to a function with different pole locations). That can be achieved like this:

With[{maximumModulus = 10},
VectorPlot[{Re[f[x + I*y]], Im[f[x + I*y]]}, {x, -1.5, 1.5}, {y, -1,
1}, VectorPoints -> Fine,
VectorScale -> {Automatic, Automatic,
If[#5 > maximumModulus, 0, #5] &}]
]


The main thing here is that as the third element of the VectorScale option I provided a function that takes the 5th argument (which is the norm of the vector field) and outputs a nonzero vector scale only when the field is smaller than the cutoff value maximumModulus.

Another possibility is to encode the modulus not in the vector length at all, but in the color of the arrows:

VectorPlot[{Re[f[x + I*y]], Im[f[x + I*y]]}, {x, -1.5, 1.5}, {y, -1,
1}, VectorPoints -> Fine,
VectorScale -> {Automatic, Automatic, None},
VectorColorFunction -> (Hue[2 ArcTan[#5]/Pi] &),
VectorColorFunctionScaling -> False]


What I did here is to suppress the automatic re-scaling colors in VectorColorFunction and provided my own scaling that can easily deal with infinite values. It's based on the ArcTan function.

As a mix between these two approaches, you could also use the ArcTan to rescale vector length.

-
Thanks Jens! This takes into account all of the previous suggestions and then some and is probably the ideal way to do Pólya plots. –  Jackson Walters Apr 14 '12 at 17:08
By the way, Hue as a color scheme was only a quick-and-dirty choice. If you use a more systematic gradient such as VectorColorFunction -> ( ColorData["Rainbow"][2 ArcTan[#5]/\[Pi]] &) then it becomes a little easier to interpret the colors. For example, this function has three zeros and a pole: f[z_] := 1/z + (z - 1)^2 - and Hue doesn't show that so clearly. –  Jens Apr 14 '12 at 18:05
Good point. I've been playing around with higher values of VectorPoint and that seems to give a really intuitive picture of what's going on. I think I'll edit my post and show a couple of interesting plots such as $sin(z)$, $\Gamma(z)$, and some functions with interesting pole/zero structure. –  Jackson Walters Apr 14 '12 at 18:35
Just for completeness, it would be good to write down the definition of your final plot function PolyaPlot too... –  Jens Apr 14 '12 at 18:55
Done. Thanks again! –  Jackson Walters Apr 14 '12 at 19:02

If you don't know where the poles might be, just cut the function at a certain maximal value to leave a blank area around the pole:

g[z_] = 1/z;
h[z_] = If[Abs[g[z]] > 4, 0, g[z]];
VectorPlot[{Re[h[x + I*y]], Im[h[x + I*y]]}, {x, -1.5, 1.5}, {y, -1.5,
1.5}, VectorPoints -> Fine]


This also allows to see better the smaller vector values, without them being scaled down to much (depending on your choice of threshold).

Otherwise, if you know where the poles are, I'll suggest a slightly ad-hoc alternative to b.gate’s very nice solution: just make your function be zero at the poles!

g[z_] = 1/z;
VectorPlot[
If[x == 0 && y == 0, {0, 0}, {Re[g[x + I*y]],
Im[g[x + I*y]]}], {x, -1.5, 1.5}, {y, -1.5, 1.5},
VectorPoints -> Fine]


-
Cool, that should do the trick. BTW, I just tried using StreamPlot and it seems to not have any of the issues that VectorPlot has while providing more or less the same information. –  Jackson Walters Apr 14 '12 at 14:53

You can try using RegionFunction :

g[z_] = 1/z
VectorPlot[{Re[g[x + I*y]], Im[g[x + I*y]]}, {x, -1.5, 1.5}, {y, -1.5,1.5},
VectorPoints -> Fine, RegionFunction -> Function[{x, y}, x^2 + y^2 >= 0.005]]


Another alternative is to specify explicitly the points at which you want the field :

points = Flatten[Table[{x, y}, {x, Range[-1, 1, 0.5]}, {y, Range[-1, 1, 0.5]}], 1]
VectorPlot[{Re[g[x + I*y]], Im[g[x + I*y]]}, {x, -1.5, 1.5}, {y, -1.5,1.5},
VectorPoints -> points, RegionFunction -> Function[{x, y}, x^2 + y^2 >= 0.005]]


-
Thanks! This is really nice, however I'm finding that it's still very fragile. Decreasing the bounds to $\left[ -1, 1\right]^{2}$ causes it break. –  Jackson Walters Apr 14 '12 at 14:05
@JacksonWalters Added a better suggestion, please see if this helps. –  b.gatessucks Apr 14 '12 at 15:00
your arrow at the pole (0,0) is weird, isn't it? –  F'x Apr 14 '12 at 15:48
@F'x Yes and the documentation says that "VectorPlot omits any vectors for which the Subscript[v, i] etc. do not evaluate to real numbers". One can use RegionFunction together with VectorPoints but hopefully someone will post a better answer. –  b.gatessucks Apr 14 '12 at 16:04