 # passing 1D or 2D arrays to contour, pcolor, image, plot

I am following up on the discussion of passing a single 2D array to plot.
Wouldn’t it make more sense that, in Python array style,
if you give it a single N x K argument you plot rows against the first row?

On the same token, it would be really nice if contour, pcolor and image
take as an x and y argument not only a matrix but just a 1D row. This
should be really easy and would be very useful.

In fact, if more people want it I can submit a patch for the latter one,

Mark

···

Message: 4
Date: Wed, 12 Jul 2006 14:38:46 -0400

From: Alan G Isaac <aisaac@…310…>
Subject: Re: [Matplotlib-users] ANN: matplotlib-0.87.4 (bugfix release
for enthon)
To:
matplotlib-users@lists.sourceforge.net
Message-ID: <Mahogany-0.66.0-1448-20060712-143846.00@…310…>
Content-Type: TEXT/PLAIN; CHARSET=ISO-8859-1

On Wed, 12 Jul 2006, Eric Firing apparently wrote:

In the single-argument NxK case, I think matlab plots
subsequent columns against the first column. Is this what
you would like?

Yes.

Cheers,
Alan Isaac

That's not the behavior I would have expected. I would have expected each row
to be plotted as a funtion of the column index, just like plot([1,2,3,4]) is
done now, but with each row in a different color. I would like
plot([1,2,3,4], array([[1,2,3,4],[2,3,4,5]])) to plot two lines as a function
of the single x-list, and I would like plot(array([[1,2,3,4],[2,3,4,5]]),
array([[1,2,3,4],[2,3,4,5]])) to take the next obvious step. I *think* matlab
does this, but its been so long since I used it...

Darren

···

On Wednesday 12 July 2006 16:16, Mark Bakker wrote:

I am following up on the discussion of passing a single 2D array to plot.
Wouldn't it make more sense that, in Python array style,
if you give it a single N x K argument you plot rows against the first row?

Mark Bakker wrote:

On the same token, it would be really nice if contour, pcolor and image
take as an x and y argument not only a matrix but just a 1D row. This
should be really easy and would be very useful.

contour already does this, and I agree that pcolor and pcolormesh should. pcolor* is a little more complicated than contour because the X and Y dimensions are ideally larger by 1 than the corresponding Z dimensions, but don't have to be.

image does not take x,y arguments at all, by design.

In fact, if more people want it I can submit a patch for the latter one,

OK. I suggest a function that can be used for both pcolor and pcolormesh. (Some day the two should be consolidated, but there is a pcolormesh bug with alpha != 1, so we can't do it yet.)

Eric

Darren Dale wrote:

I am following up on the discussion of passing a single 2D array to plot.
Wouldn't it make more sense that, in Python array style,
if you give it a single N x K argument you plot rows against the first row?

That's not the behavior I would have expected. I would have expected each row to be plotted as a funtion of the column index, just like plot([1,2,3,4]) is done now, but with each row in a different color. I would like plot([1,2,3,4], array([[1,2,3,4],[2,3,4,5]])) to plot two lines as a function of the single x-list, and I would like plot(array([[1,2,3,4],[2,3,4,5]]), array([[1,2,3,4],[2,3,4,5]])) to take the next obvious step. I *think* matlab does this, but its been so long since I used it...

I was afraid someone would bring up these possibilities...

One of the problems with fancy argument handling is that there are many ways it can be done, so we have to decide on the behavior we want; and inevitably this will surprise (and probably irritate) some people just as it pleases others. (Other problems include complex code, complex documentation, and runtime overhead. For interactive use, however, fancy argument handling may be worth the trouble.)

We are going to have some tradeoffs among matlab compatibility, internal consistency, and adherence to the underlying data storage model.

Here is what Matlab does (and in one respect it is not what I thought I remembered):

1) Given a single NxK matrix, it plots each column against the row index.

2) Given a vector and an NxK, it plots each column against the vector.

3) Given an NxK and a vector, it plots the vector against each column.

4) Given an NxK and an NxK it plots each column from the second against the corresponding column of the first.

I think this is a good model: fairly simple, consistent, intuitive, and covers a good range of real-life situations. It differs from what I thought I remembered, and from what I think Stefan requested, in that, given an Nx2, it does not plot the second column against the first. That behavior, however, does not generalize nicely to NxK for any K!=2, so I now think we should choose either one or the other. A virtue of Stefan's Nx2 proposal is that it is consistent with the changes I made to elsewhere so that paths can be specified as Nx2 arrays; this, in turn, was consistent with the original specification as sequences of (x,y) tuples. But plot has never used sequences of (x,y) tuples, so the argument for the Nx2 form is weaker here.

I don't know whether the reason Matlab chooses the columns as the data vectors is because of the Fortran storage order Matlab uses, or whether there is some other reason. Personally I am very comfortable with it, perhaps simply because of my Matlab experience. I think part of it is that columns in a table seem more natural as data vectors than rows, however; tables are usually oriented so that columns (fields) are different variables, and the row index is the sample number, or time, or a spatial coordinate.

To summarize, the options seem to be:

1) Leave plot argument parsing alone.
2) Accept an Nx2 array in place of a pair of arguments containing x and y.

3) Implement the Matlab model.
4) Implement the Matlab model, but taking rows instead of columns in an X or Y array that is 2-D.

I am open to arguments, but my preference is the Matlab model. I don't think that the difference in native array storage order matters much. It is more important to have the API at the plot method and function level match the way people think.

Eric

···

On Wednesday 12 July 2006 16:16, Mark Bakker wrote:

Darren Dale wrote:
>>I am following up on the discussion of passing a single 2D array to plot.
>>Wouldn't it make more sense that, in Python array style,
>>if you give it a single N x K argument you plot rows against the first
>> row?
>
> That's not the behavior I would have expected. I would have expected each
> row to be plotted as a funtion of the column index, just like
> plot([1,2,3,4]) is done now, but with each row in a different color. I
> would like
> plot([1,2,3,4], array([[1,2,3,4],[2,3,4,5]])) to plot two lines as a
> function of the single x-list, and I would like
> plot(array([[1,2,3,4],[2,3,4,5]]), array([[1,2,3,4],[2,3,4,5]])) to take
> the next obvious step. I *think* matlab does this, but its been so long
> since I used it...

I was afraid someone would bring up these possibilities...

Let me temper what I said. *If* a change was considered, what I described
seems to be the most intuitive behavior.

We are going to have some tradeoffs among matlab compatibility, internal
consistency, and adherence to the underlying data storage model.

agreed

Here is what Matlab does (and in one respect it is not what I thought I
remembered):

1) Given a single NxK matrix, it plots each column against the row index.

2) Given a vector and an NxK, it plots each column against the vector.

3) Given an NxK and a vector, it plots the vector against each column.

4) Given an NxK and an NxK it plots each column from the second against
the corresponding column of the first.

I think this is a good model: fairly simple, consistent, intuitive, and
covers a good range of real-life situations. It differs from what I
thought I remembered, and from what I think Stefan requested, in that,
given an Nx2, it does not plot the second column against the first.
That behavior, however, does not generalize nicely to NxK for any K!=2,
so I now think we should choose either one or the other. A virtue of
Stefan's Nx2 proposal is that it is consistent with the changes I made
to elsewhere so that paths can be specified as Nx2 arrays; this, in
turn, was consistent with the original specification as sequences of
(x,y) tuples. But plot has never used sequences of (x,y) tuples, so the
argument for the Nx2 form is weaker here.

I don't know whether the reason Matlab chooses the columns as the data
vectors is because of the Fortran storage order Matlab uses, or whether
there is some other reason.

I believe this is the reason.

Personally I am very comfortable with it,
perhaps simply because of my Matlab experience. I think part of it is
that columns in a table seem more natural as data vectors than rows,
however; tables are usually oriented so that columns (fields) are
different variables, and the row index is the sample number, or time, or
a spatial coordinate.

To summarize, the options seem to be:

1) Leave plot argument parsing alone.
2) Accept an Nx2 array in place of a pair of arguments containing x and y.

3) Implement the Matlab model.
4) Implement the Matlab model, but taking rows instead of columns in an
X or Y array that is 2-D.

I am open to arguments, but my preference is the Matlab model. I don't
think that the difference in native array storage order matters much.
It is more important to have the API at the plot method and function
level match the way people think.

I would probably use 4, but not 3. I don't like the sound of 2. But that's
just my opinion.

Darren

···

On Wednesday 12 July 2006 7:19 pm, you wrote:

> On Wednesday 12 July 2006 16:16, Mark Bakker wrote:

+1

Cheers,
Alan Isaac

PS This is fairly close to the (more constrained) GAUSS model.

···

On Wed, 12 Jul 2006, Eric Firing apparently wrote:

3) Implement the Matlab model.

I wasn't aware of the matlab model when I made the suggestion --
havn't used it for such a long time! Option (3) looks good for
consistency: for one argument, always plot agains row index, for two
arguments, plot columns of x to columns of y, using broadcasting if
necessary (i.e. if either x or y is a vector).

Regards
Stéfan

···

On Wed, Jul 12, 2006 at 01:19:41PM -1000, Eric Firing wrote:

To summarize, the options seem to be:

1) Leave plot argument parsing alone.
2) Accept an Nx2 array in place of a pair of arguments containing x and y.

3) Implement the Matlab model.
4) Implement the Matlab model, but taking rows instead of columns in an
X or Y array that is 2-D.

I am open to arguments, but my preference is the Matlab model. I don't
think that the difference in native array storage order matters much.
It is more important to have the API at the plot method and function
level match the way people think.