matplotlib-users Mailing List for matplotlib

Hi,

I think there is a good reason to add the functionality to plot
pre-computed histograms to hist() or to a new function with similar API.

Sometimes histograms are heavy or we don't want to recompute them to
perform a series of plots.

In this case, I miss the ability to easily set the plot style. hist()
allows to chose between bar, step and stepfilled. To change the style with
pre-computed histograms, I need to write 3 different "plots" using bar(),
plot() and fill_between() respectively. This is quite inconvenient and
error prone, considering that these function have different API for the
input data.

Maybe the plotting part of hist() should be splitted in a standalone
function (plotbins() ?)
In this way, hist() can call this function to generate the plot, but also
the user can call it when the histogram is pre-computed. The bonus is that
we retain the same API for plot style.

My 2cents,
Antonio


On Fri, Apr 24, 2015 at 4:31 AM, Jerzy Karczmarczuk <
jer...@un...> wrote:

>
> Le 24/04/2015 12:58, Christian Alis responds to the problem posed by
> Virgil Stokes
> > I had the same problem some time ago and what I did is to use bar() to
> > plot the histogram, which can be done in one line:
> >
> > hst, bin_edges = np.histogram(data)
> > plt.bar(bin_edges[:-1], hst)
> >
> > Perhaps this trick can be added in the documentation?
> >
> > I am willing to code Virgil's request if many will find this useful.
> Separating the computation of the histogram, and plotting it is
> obviously useful.
> (I needed this in a linguistical simulation context, where plotting had
> no sense).
>
> Actually hist is more or less this,
> see _axes.py, line 5678, the Axes method hist just calls
> numpy.histogram. And then plots bars (or uses some other style).
>
> So, although completing the documentation might be of general interest,
> I would NOT recommend adding some new version of hist.
> This would be misleading. Hist is hist is hist(ogram). It computes the
> histogram (and eventually plots it). If it is already computed elsewhere,
> naming  the procedure which JUST plots some bars a "histogram" is
> methodologically very dubious.
>
> Jerzy Karczmarczuk
>
>
>
> ------------------------------------------------------------------------------
> One dashboard for servers and applications across Physical-Virtual-Cloud
> Widest out-of-the-box monitoring support with 50+ applications
> Performance metrics, stats and reports that give you Actionable Insights
> Deep dive visibility with transaction tracing using APM Insight.
> http://ad.doubleclick.net/ddm/clk/290420510;117567292;y
> _______________________________________________
> Matplotlib-users mailing list
> Mat...@li...
> https://lists.sourceforge.net/lists/listinfo/matplotlib-users
>

Hi Matplotlib Users,

When I make wind barbs with rounding enabled and custom barb increments I
noticed that there were no wind barbs with half barbs above 2 full barbs.
The reason seems to be a bug in the _find_tails method. The bug is
illustrated by this small script (_find_tails is a copy of the one in
matplotlib):

import numpy as np

def _find_tails(self, mag, rounding=True, half=5, full=10, flag=50):
    '''
    Find how many of each of the tail pieces is necessary.  Flag
    specifies the increment for a flag, barb for a full barb, and half for
    half a barb. Mag should be the magnitude of a vector (ie. >= 0).

    This returns a tuple of:

        (*number of flags*, *number of barbs*, *half_flag*, *empty_flag*)

    *half_flag* is a boolean whether half of a barb is needed,
    since there should only ever be one half on a given
    barb. *empty_flag* flag is an array of flags to easily tell if
    a barb is empty (too low to plot any barbs/flags.
    '''

    #If rounding, round to the nearest multiple of half, the smallest
    #increment
    if rounding:
        mag = half * (mag / half + 0.5).astype(np.int)

    num_flags = np.floor(mag / flag).astype(np.int)
    mag = np.mod(mag, flag)

    num_barb = np.floor(mag / full).astype(np.int)
    mag = np.mod(mag, full)

    half_flag = mag >= half
    empty_flag = ~(half_flag | (num_flags > 0) | (num_barb > 0))

    return num_flags, num_barb, half_flag, empty_flag

def main():
    mag = np.arange(0,21,1)
    barb_incs = {'half': 2.57222,
                 'full': 5.14444,
                 'flag': 25.7222}
    print 'With rounding'
    num_flags, num_barb, half_flag, empty_flag =  _find_tails(None, mag,
rounding=True, **barb_incs)
    for i in range(len(mag)):
        print mag[i], num_flags[i], num_barb[i], half_flag[i], empty_flag[i]
    print 'Without rounding'
    num_flags, num_barb, half_flag, empty_flag =  _find_tails(None, mag,
rounding=False, **barb_incs)
    for i in range(len(mag)):
        print mag[i], num_flags[i], num_barb[i], half_flag[i], empty_flag[i]

if __name__ == '__main__':
    exit(main())

It seems like the error is not present when the barb increments are not
set. I believe the reason for the bug is the float comparison (half_flag =
mag >= half) where the value is rounded to a value very close to/identical
to the 'half' increment. And it seems like python does the right thing when
the "half" increment is a whole number but not always when it is not.

But in any case the code should probably not depend two floats being equal.

Best regards,
Jesper

Le 24/04/2015 12:58, Christian Alis responds to the problem posed by 
Virgil Stokes
> I had the same problem some time ago and what I did is to use bar() to
> plot the histogram, which can be done in one line:
>
> hst, bin_edges = np.histogram(data)
> plt.bar(bin_edges[:-1], hst)
>
> Perhaps this trick can be added in the documentation?
>
> I am willing to code Virgil's request if many will find this useful.
Separating the computation of the histogram, and plotting it is 
obviously useful.
(I needed this in a linguistical simulation context, where plotting had 
no sense).

Actually hist is more or less this,
see _axes.py, line 5678, the Axes method hist just calls 
numpy.histogram. And then plots bars (or uses some other style).

So, although completing the documentation might be of general interest, 
I would NOT recommend adding some new version of hist.
This would be misleading. Hist is hist is hist(ogram). It computes the 
histogram (and eventually plots it). If it is already computed elsewhere,
naming  the procedure which JUST plots some bars a "histogram" is 
methodologically very dubious.

Jerzy Karczmarczuk

On 24-Apr-2015 12:58, Christian Alis wrote:
> I had the same problem some time ago and what I did is to use bar() to
> plot the histogram, which can be done in one line:
>
> hist, bin_edges = np.histogram(data)
> plt.bar(bin_edges[:-1], hist)
Very elegant Christian :-)
>
> Perhaps this trick can be added in the documentation?
Well, I vote to add it. However, I did find the following nice example (after 
reading your email) that shows how the bar function might be used 
(http://matplotlib.org/examples/api/barchart_demo.html) for my problem. Had I 
seen this before, I probably would not have posted this request.:-[
>
> I am willing to code Virgil's request if many will find this useful.
>
>
> On Fri, Apr 24, 2015 at 11:33 AM, Virgil Stokes <vs...@it...> wrote:
>> I have some Python (2.7.9) code that processes some rather large data sets
>> to determine the curvatures along 2D curves. One feature of these data that
>> I like to look at is the distribution of the curvatures. I use NumPy to to
>> determine histograms for each set, and save the histogram parameters
>> returned from numpy.histogram in a file.
>>
>> I would like to use Matplotlib to plot histograms from the parameters
>> returned in NumPy and stored in a file --- why? Because the size of my data
>> sets does not allow for the use of the histogram plot function in Matplotlib
>> (1.4.3); i.e., it needs the data sets to calculate the histogram, before
>> doing the plot. I would like to have a histogram plot function in Matplotlib
>> that could bypass the actual calculation of the bin counts and edges from
>> the data, and use values of these found a priori. Of course, an obvious
>> question is -- Why not write code to plot the rectangles yourself? Yes, I
>> could do this; but, why not extend the Matplotlib histogram class to allow
>> for this option? If I better understood Matplotlib, I would try this myself.
>> Maybe it is possible to get this into the next planned release (1.5). :-)
>>
>> If this request is inappropriate for this list, then please accept my
>> apology and direct me to where I should send this request.
>>
>> Best regards.
>>
>> ------------------------------------------------------------------------------
>> One dashboard for servers and applications across Physical-Virtual-Cloud
>> Widest out-of-the-box monitoring support with 50+ applications
>> Performance metrics, stats and reports that give you Actionable Insights
>> Deep dive visibility with transaction tracing using APM Insight.
>> http://ad.doubleclick.net/ddm/clk/290420510;117567292;y
>> _______________________________________________
>> Matplotlib-users mailing list
>> Mat...@li...
>> https://lists.sourceforge.net/lists/listinfo/matplotlib-users
>>
Keep up the good work on Matplotlib and I look forward to vers. 1.5 :-)

I had the same problem some time ago and what I did is to use bar() to
plot the histogram, which can be done in one line:

hist, bin_edges = np.histogram(data)
plt.bar(bin_edges[:-1], hist)

Perhaps this trick can be added in the documentation?

I am willing to code Virgil's request if many will find this useful.


On Fri, Apr 24, 2015 at 11:33 AM, Virgil Stokes <vs...@it...> wrote:
> I have some Python (2.7.9) code that processes some rather large data sets
> to determine the curvatures along 2D curves. One feature of these data that
> I like to look at is the distribution of the curvatures. I use NumPy to to
> determine histograms for each set, and save the histogram parameters
> returned from numpy.histogram in a file.
>
> I would like to use Matplotlib to plot histograms from the parameters
> returned in NumPy and stored in a file --- why? Because the size of my data
> sets does not allow for the use of the histogram plot function in Matplotlib
> (1.4.3); i.e., it needs the data sets to calculate the histogram, before
> doing the plot. I would like to have a histogram plot function in Matplotlib
> that could bypass the actual calculation of the bin counts and edges from
> the data, and use values of these found a priori. Of course, an obvious
> question is -- Why not write code to plot the rectangles yourself? Yes, I
> could do this; but, why not extend the Matplotlib histogram class to allow
> for this option? If I better understood Matplotlib, I would try this myself.
> Maybe it is possible to get this into the next planned release (1.5). :-)
>
> If this request is inappropriate for this list, then please accept my
> apology and direct me to where I should send this request.
>
> Best regards.
>
> ------------------------------------------------------------------------------
> One dashboard for servers and applications across Physical-Virtual-Cloud
> Widest out-of-the-box monitoring support with 50+ applications
> Performance metrics, stats and reports that give you Actionable Insights
> Deep dive visibility with transaction tracing using APM Insight.
> http://ad.doubleclick.net/ddm/clk/290420510;117567292;y
> _______________________________________________
> Matplotlib-users mailing list
> Mat...@li...
> https://lists.sourceforge.net/lists/listinfo/matplotlib-users
>

I have some Python (2.7.9) code that processes some rather large data sets to 
determine the curvatures along 2D curves. One feature of these data that I like 
to look at is the distribution of the curvatures. I use NumPy to to determine 
histograms for each set, and save the histogram parameters returned from 
numpy.histogram in a file.

I would like to use Matplotlib to plot histograms *from the parameters returned 
in NumPy* and stored in a file --- why? Because the size of my data sets does 
not allow for the use of the histogram plot function in Matplotlib (1.4.3); 
i.e., it needs the data sets to calculate the histogram, before doing the plot. 
I would like to have a histogram plot function in Matplotlib that could bypass 
the actual calculation of the bin counts and edges from the data, and use values 
of these found /a priori/. Of course, an obvious question is -- Why not write 
code to plot the rectangles yourself? Yes, I could do this; but, why not extend 
the Matplotlib histogram class to allow for this option? If I better understood 
Matplotlib, I would try this myself. Maybe it is possible to get this into the 
next planned release (1.5).:-)

If this request is inappropriate for this list, then please accept my apology 
and direct me to where I should send this request.

Best regards.

On 23-Apr-2015 20:09, Jerzy Karczmarczuk wrote:
> Animation problem of Virgil Stokes.
>
> Since I began the answer sequence, here's a little more. If this overlaps 
> other answers, I apologize.
>
> About the third parameter
>>> "/frames/ can be a generator, an iterable, or a number of frames."
>> This makes very little sense to me --- what does "or a number of frames" mean?
>>> The name "data_gen" could suggest its meaning (after having read the doc). 
>> I am not sure what you are referencing as "the doc"; but I did read the 
>> documentation several times and English is my native language.
> I am not trying to accuse you of anything, I simply underline that if the 
> documentation - as cited - mentions the word *generator*, and the program 
> contains the argument *data_gen*, which is OBVIOUSLY a generator which 
> *yields* some data, then this might have give you some clues concerning its 
> meaning.
Ok Jerzy --- I apologize for my reaction and you are correct, I should have 
taken "generator" more seriously.
>
>>> Note please that the keyword parameters are specified extra.
>> I am aware of this.  Perhaps, I am a Python dummy --- when I see something 
>> like value = None in a Python API argument, I interpret this as a keyword 
>> argument and not a generator.
>
> 1. Generators might be or not function arguments, keyword or not; this is not 
> an issue here. Generators are entities which produce iterators.  Here you 
> have: *def data_gen(): while True: yield np.random.rand(10)* , and this is all.
Yes, again Jerzy.
>
> 2. When you see "frames=None", etc., this doesn't absolutely mean that it is a 
> kw parameter, just a positional parameter with a default value.
> Brendan Barnwell commented this already.
> If you look at the definition of the FuncAnimation class, which is readable, 
> in the file ... matplotlib/animation.py, you will see
> *def __init__(self, fig, func, frames=None, init_func=None, fargs=None, 
> save_count=None, **kwargs):**
> **   ...*
> which explicitly confirms this.
>
> I think that you got the answers you demanded. The FuncAnimation callback 
> *requires* one argument, even if you don't use it. It may be the frame number 
> (or index if you wish), or explicit, specific data, such as in your first 
> example.
> If, as in your second example, the parameter passed is the frame index, and 
> you want to see how you can use it, test this:
>
> *x=np.linspace(0,20,300)***
>
> *   def update(i):*
>
> **
>
> **
>
> *    data=(np.sin(x+i/3)+1)/2*
>
> **
>
> *    line.set_ydata(data)*
>
> **
>
> *
> *
>
> *ani = animation.FuncAnimation(fig, update, interval=40)*
>
>
> You should see a moving sinusoid.
Yes, I have written something like this myself in an attempt to better 
understand Matplotlib animation. IMHO, the documentation for FuncAnimation 
should explicitly state that one argument is required for the animation 
function. The documentation does state:

   "Makes an animation by repeatedly calling a function /func/, passing in 
(optional) arguments in /fargs/."

But of course this is my opinion.
>
>>>
>>> Please, in such cases test your programs by adding some simple tracing 
>>> contraptions, say, print(data) inside update.
>> I did this and more before posting my email. I would not have posted this 
>> unless I thought it was necessary. And I thought one purpose of this user 
>> group was to help people --- even if they ask a question which may be 
>> annoying or "stupid" in some subscribers opinion. I try to remember what a 
>> very wise teacher once said --- "there is no such thing as a stupid question".
>
> I don't understand your reaction.  I teach computer science for many years, 
> and several times per week I suggest to my students to do this, to trace their 
> programs. I trace mine. 
I have also taught programming and I often make the same suggestion and of 
course this is a suggestion that I follow myself. And I did this before posting. 
One thing that led me astray was the error message that was generated when I 
removed the argument to the animate function. I even went into the source of 
Matplotlib in an attempt to answer this; but, I still could not resolve this issue.
> Nobody feels offended. You said: data is undefined. But it WAS DEFINED, you 
> agree? So, printing its value was the most natural suggestion. You would 
> immediately see that it had been generated by data_gen.
Yes, I did see this and this was one thing that confused me.
>
> Also, I recommend that you look upon the sources of Matplotlib from time to 
> time. I do it regularly, it is nicely commented, and complements very well the 
> documentation.
I have done this several times; but, I find this package very complex and 
difficult to unravel. I use Matplotlib a lot and it is a fantastic package --- 
great work by the developer team. The fact that I do not always need to know 
what is "under the cover" of Matplotlib, is IMHO a positive thing, and a good 
indicator that the documentation (including the examples and gallery) is rather 
well done.
>
> Jerzy Karczmarczuk
>
> PS. Some blizzard around positional/keyword parameters in Python is quite 
> persistent.  "Dive into Python" of Mark Pilgrim covers this, and offers some 
> useful references.
I recently obtained this book; but, have not "dived" into it yet  It now seems 
clear that I should take the plunge soon :-)

Best regards, and thanks for your follow-up Jerzy,
--V