Basically, I'm trying to produce the same output that Histogram[giganticList] would produce, but starting from the output of HistogramList[giganticList] instead of giganticList.

The closest I've been able to find is to pass to BarChart the bin counts produced by HistogramList; i.e. something like

bc = HistogramList[giganticList];


This produces a chart whose horizontal axis is improperly scaled, which is not surprising, since I have not given BarChart any information that would enable it to do otherwise. I have not found a way to do so.


I need the output of both HistogramList and Histogram on a whole bunch of lists.

When inputList is small enough, it's no big deal to call both HistogramList[inputList] and Histogram[inputList], even if this (according to the documentation) amounts to calling HistogramList[inputList] twice.

But I need to do this for several hundred lists, each consisting of about 2 million numbers. A call to HistogramList on any one of these lists costs ~1 minute a pop, so avoiding that duplicate call to HistogramList is to me significant enough to be worth the trouble.

The documentation page for HistogramList shows that one can pass to BarChart the last member of the pair returned by HistogramList to approximate the output that Histogram would produce with the same input, but, as already explained, the resulting chart's horizontal axis is not properly scaled.

The documentation page for BarChart, on the other hand, is huge, and is filled with outlandish possibilities, such as how to make a bar chart out of copies of a famous pornographic image (or, rather, of a sufficiently decorous fragment thereof), but I'm having no luck finding in all this clutter a way to do what I'm trying to do. Too pedestrian, maybe...


For historical reasons I need to stick with the "look" that Histogram produces by default, so I adapted lalmei's answer.

I post my embarrassing, plodding code below, because I'm sure one of you can do it much better. (More generally, comments and criticism on this code are always welcome.)

myHistogram[hl_] := Module[{makexs, makeys, xs, ys},

  (* makexs basically converts { ..., a, b, c, ... } into
     Flatten[{ ..., {a, a, a}, {b, b, b}, {c, c, c}... }]
     ...and then fixes the result's "boundaries" *)
  makexs = Function[Drop[Drop[Flatten[Transpose[{#, #, #}], 1], 1], -1]];

  (* makeys basically converts { ..., a, b, c, d, ... } into
     Flatten[{ ..., {a, 0, b}, {b, 0, c}, {c, 0, d}... }]
     ...and then fixes the result's "boundaries" *)
  makeys =
        Flatten[Select[#, (# =!= None &)] & /@ 
                ({First[#], 0, Last[#]} & /@
                 (Transpose[{Prepend[#, None], Append[#, None]}]) & @ #)

  xs = makexs[First[hl]];

  ys = makeys[Last[hl]];

   Transpose[{xs, ys}],
   Joined -> True, 
   Filling -> {1 -> Axis}, 
   FillingStyle -> RGBColor[0.987148, 0.8073604, 0.4947004],
   PlotRange -> {{First[xs], Last[xs]}, {All, All}},
   PlotRangePadding -> {{Scaled[0.02], Scaled[0.02]},
                        {Scaled[0.02], Scaled[0.05]}},
   AxesOrigin -> {1.02 First[xs] - 0.02 Last[xs], 0},
   PlotStyle -> {Black, Thickness[Small], Antialiasing -> False}


data = RandomVariate[NormalDistribution[0, 1], 1000];


Mathematica graphics


Mathematica graphics


2 Answers 2


While not a Bar Chart per se, I usually prefer to use the result from HistrogramList directly with ListPlot and then join the points with InterpolationOrder->0.

data = RandomVariate[NormalDistribution[0, 1], 1000];
mapoints=Thread[{#[[1]], Append[#[[2]], 0.0]}] &@HistogramList[data];

  Joined -> True, InterpolationOrder -> 0, Filling -> {1 -> Axis}, 
  Frame -> True, Axes -> False]

enter image description here


Ok, if you really want the bars, your update gave me an idea. Essentially add zeros in between the bins and keep the same settings.

mazeropoints = 
Thread[{#[[1, 2 ;; -2]], ConstantArray[0.0, Length[#[[1]]] - 2]}] &@

Now just join with the original points, and make sure to sort them, or Joined doesn't work properly.

ListPlot[SortBy[Join[mapoints, mazeropoints], First], 
 Joined -> True, InterpolationOrder -> 0, Filling -> {1 -> Axis}, 
 Frame -> True, Axes -> False]

enter image description here

If you have errors associated with the bins you can also easily add them to the middle of the bins using MovingAverage

some fake errors::

maerrors = (Sqrt[#]*
  RandomVariate[NormalDistribution[0, 2]]) & /@ (Last@

 maMiddlepointserrors = 
 Thread[{Thread[{MovingAverage[#[[1]], 2], #[[2]]}] &@
 HistogramList[data], maerrors}];

 Show[ListPlot[SortBy[Join[mapoints, mazeropoints], First], 
   Joined -> True, InterpolationOrder -> 0, Filling -> {1 -> Axis}, 
   Frame -> True, Axes -> False], 
   Graphics[{Lighter@Lighter@Blue, Thick, 
   Line[{First@# + {0, Last@#}, First@# - {0, Last@#}}] & /@ 

enter image description here


You can already achieve this using Histogram. No need to fuss with ListPlot.

Use these forms for the second and third arguments of Histogram, and ignore the first argument:

The following bin width specifications $bspec$ can be given:

  • $\{\{b_1,b_2,\dots\}\}\qquad$ use the bins $[b_1,b_2),[b_2,b_3),\dots$
  • $\mathit{fb}\qquad\qquad\qquad\,\,$ apply $\mathit{fb}$ to get an explicit bin specification $\{b_1,b_2,\dots\}$

Different forms of histogram can be obtained by giving different bin height specifications $hspec$ in $\mathsf{Histogram}[data,\, bspec,\, hspec]$. The following forms can be used:

  • $\mathit{fh}\qquad\qquad\qquad\,\,$ heights obtained by applying $\mathit{fh}$ to bins and counts

HistogramList essentially returns $\{b,\,h\}$, so you can easily create $\mathit{fb}$ and $\mathit{fh}$: they are just functions that always return $b$ and $h$.

This function takes the result of HistogramList (or similar data structure) and gives a Histogram:

HistogramFromHistList[histList_, opts : OptionsPattern[]] :=
      fakeData = {0, firstComesANumber, "but anything can go after"}, (*or just use {0}*)
      b, h, fb, fh
    {b, h} = histList;
    fb = b &; (*Last@b also works.*)
    fh = h &;
    Histogram[fakeData, fb, fh, opts]

Usage example:

stuf = RandomVariate[BetaDistribution[4, 2], 500];
opts = ImageSize -> 240;

  Histogram[stuf, opts],
  HistogramFromHistList[HistogramList[stuf], opts]

(* Passing more arguments to both Histogram and HistogramList still works. *)
  Histogram[stuf, {0, 1, 0.05}, "CDF", opts],
  HistogramFromHistList[HistogramList[stuf, {0, 1, 0.05}, "CDF"], opts]

Edit: The same technique can be used to answer these very similar questions:


Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.