Arrow length goes wild near poles in vector field plot

edit

neat! thank you, rburing! I do need to figure out those lambda functions...

Could you please explain a little what happens in those lambda functions? especially the .subs() is confusing to me. Also the "else None" seems to be the limitation and only happens if abs(x) + abs(y) exceed the limit, but how does it limit, really? it does not replace anything in that case, does it? Is my_grad just a copy of grad? and it only copies if it does not exceed? does the subs() only happen in case if() is true?

is it perhaps like this (in pseudo code): if (grad_len < 7) then (copy x and y), else (don't). why would you have two subs in the second case, not just one as in the first?

Your grad is a pair of symbolic expressions; my_grad is a pair of functions of x and y (defined inline, using lambda). The function plot_vector_field accepts both forms; in the first case it substitutes numeric values into the expressions and in the second case it calls the functions with numeric arguments. The functions in my_grad return the same result as grad would (by substituting into the expressions), but when some condition is not satisfied they return None instead (which causes plot_vector_field not to plot the vector).

In the second example subs() is used in the condition, because it depends not just on the position (the numeric x and y) but also the vector length (i.e. on grad or grad_len, into which the numeric x and y are substituted).

thanks so kindly!

wow, i tried the second approach (so much more flexible!) and it almost brought my box to the knees - out of memory and CPU to the max... the simple example worked for me, too, but my real gradient field didn't.

what is so insanely memory intensive about this?

It was using the symbolic expression for the length of the gradient vector, which was not a very good idea. I updated the answer. Now the gradient vector is computed numerically first, and then the length is taken. Another optimization is to use the conditional (if ... else None) only on the first coordinate. There is still some inefficiency since one component of the numerical gradient is computed twice (once for the condition, and once for the return value). Let me know if it is still too inefficient.