Plotting Error Bars on a Log Scale

Question

I have a plot with ErrorListPlot

data = Sort@RandomReal[1, {10, 2}];
error = RandomReal[0.5, 10];
errorplot = ErrorListPlot[
  Partition[Riffle[data, ErrorBar /@ error], 2],
  Joined -> True]

However, I would like to have it with the y-axis on a log scale. I can use ListLogPlot to get the log scale but this doesn't plot the errorbars.

logplot = ListLogPlot[
  data,
  PlotRange -> All,
  AxesOrigin -> {0, 0},
  Joined -> True
  ]

I tried Show[logplot, errorplot, PlotRange->All] to see if it would plot with the scale and ticks from the logplot but that didn't work right:

I also tried to take the Ticks from the logplot: Show[errorplot, Ticks -> Ticks /. AbsoluteOptions@logplot] but that just gives an error.

I tried to manually take the log of the data and then grab the tick-marks but that didn't work right

data = Sort@RandomReal[{10, 100}, {10, 2}];
error = RandomReal[20, 10];
logdata = Transpose[{data[[All, 1]], Log[10, data[[All, 2]]]}];
errorup = Log[10, data[[All, 2]] + error] - logdata[[All, 2]];
errordown = Log[10, data[[All, 2]] - error] - logdata[[All, 2]];
logerror = Log[10, error];
logplot = ListLogPlot[
  data,
  Joined -> True,
  AxesOrigin -> {0, 0}
  ]
errorlogplot = ErrorListPlot[
  Partition[
   Riffle[logdata, ErrorBar /@ Transpose[{errordown, errorup}]], 2],
  Joined -> True,
  AxesOrigin -> {0, 0}
  ]
errorlogplot2 = ErrorListPlot[
  Partition[
   Riffle[logdata, ErrorBar /@ Transpose[{errordown, errorup}]], 2],
  Joined -> True,
  AxesOrigin -> {0, 0},
  Ticks -> (Ticks /. AbsoluteOptions@logplot)
  ]

Is there an easy way to do this?

On the log scale the error bars will appear asymmetrical.

Answer 1

I always use the package ErrorBarLogPlots. From the website:

ErrorBarLogPlots.m is a package which adds log-scale plotting functions similar to the standard ErrorListPlot provided in Mathematica 6. The added functions are ErrorListLogPlot, ErrorListLogLinearPlot, and ErrorListLogLogPlot."

Answer 2

Without using the "ErrorBarPlots`" Package

dataX = Sort@RandomReal[1, 10];
dataY = RandomReal[{0.5, 1}, 10];
error = RandomReal[0.5, 10];
errorH = dataY + error;
errorL = dataY - error;
f[y_] := Transpose[{dataX, y}];

ListLogPlot[{f[errorH], f[errorL], f[dataY]}, 
            Filling -> {1 -> {2}}, 
            Joined -> {False, False, True}]

Edit

Following @rcollyer's suggestion

dataX = Sort@RandomReal[1, 10];
dataY = RandomReal[{0.5, 1}, 10];
error = RandomReal[0.5, 10];
f[y_] := Transpose[{dataX, y}];

PlusMinus[a_, b_] := {a + b, a - b, a};
plusMinList = Thread[PlusMinus[dataY, error]];

ePlot[plotFun_, dataX_, plusMinList_] :=
 plotFun[{
   f[plusMinList[[All, 1]]],
   f[plusMinList[[All, 2]]],
   f[plusMinList[[All, 3]]]},
  Filling -> {1 -> {2}},
  Joined -> {False, False, True}]
ePlot[ListLogPlot, dataX, plusMinList]

Answer 3

A one-liner solution (see a bit below lengthy explanation)

This is a bit hacky solution, yet its simplicity prompted me to post it. Load package and make up a data set:

Needs["ErrorBarPlots`"]
data = Sort@RandomReal[1, {10, 2}]; error = RandomReal[0.2, 10];

errorplot = ErrorListPlot[Partition[Riffle[data, ErrorBar /@ error], 2], 
            Joined -> True, PlotRange -> All, Frame -> True, Axes -> False]

IMPORTANT: nothing goes below x-axis - not the data, not the error bars. Otherwise your log-scale will break - you cannot take log of negative numbers.

Now lets take a look at the "guts" of the produced graphics:

errorplot // InputForm

Line graphics primitive (sometimes with Offset) applied to sets of points given by coordinates like {x, y}. You just need to replace all these pairs by {x, Log@y}. Careful with Offset - its 1st argument needs to be left a lone. Luckily for us it has an integer 0 so it is easy to avoid applying a pattern that distinguishes it from real numbers we need to deal with.

So here is your one-liner solution:

lerrorplot = errorplot /. {x_Real, y_Real} -> {x, Log@y}

Notice undesirable non-standard ticks on vertical axes (corresponding to log values). To check that it is indeed correct - compare versus ListLogPlot:

check = ListLogPlot[data, Joined -> True, Frame -> True, 
Axes -> False, PlotStyle -> {Thickness[.03], Orange, Opacity[.3]}];
Show[check, lerrorplot, PlotRange -> All]

A perfect match. Notice the ticks on vertical axes now are in traditional log-scale type (corresponding to original un-scaled data). Of course, your error bars got log-scaled too. Warning: be careful with these ReplaceAll type of solutions - you may be up to a surprise to what exactly is getting replaced. So always analyse your code to avoid unpleasant urprises.

Answer 4

According to solution of Dr. Belisarius I wrote this more convenient code:

(* default options needed for error plot *)
Options[errListPlot] = {
   Filling -> {1 -> {2}},
   Joined -> {False, False, True},
   PlotStyle -> {Black, Black, Directive[Opacity[0.6], Blue]},
   FillingStyle -> Black,
   PlotMarkers -> {Graphics@Line[.04 {{-1, 0}, {1, 0}}], 
     Graphics@Line[.04 {{-1, 0}, {1, 0}}], ""}
   };
(*
plotFun - any ListPlot familly function;
data =List ( x, y, error );
opts - usual ListPlot options;
*)
errListPlot[plotFun_, data_, opts : OptionsPattern[]] := Block[{},
  plotFun[{{#[[1]], #[[2]] - #[[3]]} & /@ 
     data, {#[[1]], #[[2]] + #[[3]]} & /@ data, data[[;; , {1, 2}]]}, 
   opts, Sequence @@ Options[errListPlot]]
  ]
data = Table[{i, RandomReal[10], RandomReal[{0.1, 1}]}, {i, 1, 20}];
errListPlot[ListLogPlot, data, PlotRange -> All, Frame -> True, 
 FrameLabel -> {"x label", "y label"}, ImageSize -> 800, 
 BaseStyle -> {18, FontFamily -> "Arial"}]

First I set necessary options for the plot with Options[errListPlot]. Then the plot function is defined with option pattern. Supplied options will be given to targeted List-XXX-Plot function and applied to the graphics.

Be careful, supplied option will overwrite default options from Options[errListPlot]. This can be useful if you do it right or catastrophic.

Answer 5

In Mathematica 12, the ErrorBarPlots package was replaced by the built-in Around function and related methods.

Now it's possible to display errorbars on a logarithmic plot using only built-in core functions and the ListLogPlot function:

data = Sort@RandomReal[{2, 5}, {10, 2}];
error = RandomReal[0.5, 10];
toPlot = MapThread[({#1[[1]], Around[#1[[2]], #2]}) &, {data, 
    error}];
ListLogPlot[toPlot, Joined -> True, Frame -> True]