I’ve just spent a fruitless day looking through Plots, Plot.ly and PyPlot documentation, trying to find a prototype for the (2-D) quiver() diagram in Plots. I’ve discovered that it exists, and I’ve even achieved a contour diagram by entering:

quiver(1:10,1:10,rand(10,10))

But I really want a bunch of arrows, and really don’t want to fight my way any longer through the Plots code. Does anyone out there have a simple quiver example 2-dimensional flow? Thanks.

# Anyone have a Plots quiver() example?

**Niall**#1

**jheinen**#2

This example works with (pure) GR:

```
using GR
x = linspace(-2, 2, 21)
y = x
X, Y = meshgrid(x,y)
z = X.*exp(-X.^2 - Y.^2)
contour(x, y, z)
u, v = GR.gradient(x, y, z)
quiver(x, y, u, v)
```

We’ll have to ask @tbreloff - Plots seems to have another signature for the `quiver()`

function …

**Niall**#3

Thanks @jheinen. Yes, I’d already tried:

quiver(1:10,1:10,rand(10,10),rand(10,10)

and discovered the fourth parameter is the problem. I’d like if possible to stick to naked Plots code, since I’m composing a course for students. I’m intrigued though by the fact that GR doesn’t appear to need either a Matlab-like “hold on” or a Plots “quiver!”. How do you signal that the contours and the quiver are to apply to the same graphic?

**tbreloff**#4

Do a search for `quiver`

here: https://juliaplots.github.io/attributes/

The call should look something like:

```
using Plots
# setup
quiver(x, y, quiver=(u,v))
```

The quiver keyword could be replaced by aliases: `gradient, quiver2d, quivers, velocity`

.

Also you should be allowed to pass either a “vector of tuples” or a “tuple of vectors”, whichever is easier for you.

Also here is an old notebook that gives a full example… hopefully it still works

**Niall**#5

Thanks very much, @tbreloff. However I fear my newbie status is proving a problem. This may be because I’m coming at the problem from a Matlab perspective.

- The attributes reference is an abstract description which I find difficult to understand without a concrete example.
- I’m unclear from your inline example “quiver(x, y, quiver=(u,v))” what exactly the various arguments are. From a Matlab point of view I’d expect x and y to be meshgrids, however I see that in the contour plots you use linspaces instead. When I use meshgrids I get a load of error messages, and when I use linspaces, I only get arrows on a leading diagonal of points (1,1), (2,2), … Should I be using tuples?
- In the first example in the notebook you only use a single position variable y.
- In the second notebook example you use vec(), which I’ve just looked up and understand, but not why you use it. You also use P2, which I can’t find in the documentation.

Help?

**tbreloff**#6

I’d love to have examples for every attribute, but I don’t have the time to build it. Volunteers?

Vectors in this case. The arrows don’t need to be on a special grid like some other frameworks… they’re just a list of points.

The x is implicitly filled in (like many other things in Plots)

This is why your meshgrids don’t work…they should just be vectors

This is: `typealias P2 FixedSizeArrays.Vec{2,Float64}`

. Don’t worry about it… you don’t need it.

I just ran this example locally:

```
julia> using Plots
julia> u, v = rand(10),rand(10);
julia> quiver(rand(10), gradient=(u,v))
```

**stevengj**#7

Since PyPlot is just a wrapper around Matplotlib, usually you google for Matplotlib examples and then translate the syntax from Python to Julia.

e.g. have you looked at the quiver documentation, which explains all of the parameters of `quiver()`

?

**Niall**#8

Gottit! Thank you both. I was indeed encumbered by Matlab thoughts: I thought rand(10) produced a (10x10) matrix, and I didn’t understand that the graphics commands require a vector of pairs. Unfortunately I haven’t yet worked out how to format code on this forum, but here is the small test module I’ve written, in case anyone wants to use it as a code example:

```
module Plotz
export plotz;
using Plots;
function plotz(
f = (z->z*im), reRng = [-3,3], imRng = [-2,2], Δ = 0.5
)
#------------------------------------------------------
# Plot the function f(z) over the complex range
# (reRng x imRng) in steps of length delta.
#------------------------------------------------------
reRng = reRng[1]:Δ:reRng[2];
imRng = imRng[1]:Δ:imRng[2];
x = vec(repmat(reRng',length(imRng),1));
y = vec(repmat(imRng, length(reRng),1));
z = f(complex(x,y));
z = Δ*z/maximum(abs(z));
display( quiver(x,y,
quiver=(real(z),imag(z)),aspect_ratio=1)
);
return;
end;
end
```