Skip to main content

plotting - Asymmetric X and Y error bars on ListLogPlot


The wonderful error bar log plots package ErrorBarLogPlots from V6 no longer positions labels correctly (since v9 or maybe v8) so I used the same function with Prolog to place a list of labels.


Then in v10 beta PlotRangePadding no longer works either and I can't find a work around for that, so I tried to go back to basics and use the very elegant solution by Belisarius' et.al in:



Plotting Error Bars on a Log Scale


I was able to modify this to make asymmetric Y error bars, then I tried to add X-errors and got tied up in knots with the Joined and Filling commands.


The aim is to plot a set of 5 lists of xy values, {xy, xyP, xyM, xPy, xMy} where P and M refer to the plus and minus error of the x or y value preceding it, with a Filling / Joined statement that joins the first point to the other 4 points.


Ideally the plot symbols should also switch between vertical and horizontal bars for the x and y error points and something else for the x,y point. (I asked Support about including an errorlistlogplot command in Mathematica but I expect it won't make it into v10).


The lines below generate and plot the 5 sets of points. Is there a straightforward combination of Filling / Joined statements to achieve this?


SeedRandom[1234]
dataX = Sort@RandomReal[{0.5, 1}, 10];
dataY = RandomReal[{0.5, 1}, 10];
{errorYP, errorYM, errorXP, errorXM} = RandomReal[.5, {4, 10}];
dataYP = dataY + errorYP;

dataYM = dataY - errorYM;
dataXP = dataX + errorXP;
dataXM = dataX - errorXM;
xy = Transpose[{dataX, dataY}];
xyP = Transpose[{dataX, dataYP}];
xyM = Transpose[{dataX, dataYM}];
xPy = Transpose[{dataXP, dataY}];
xMy = Transpose[{dataXM, dataY}];

ePlot[plotFun_, data_] := plotFun[data, Filling -> Automatic, PlotRange -> All,

                                        Joined -> {False, False, False, False, False}];

ePlot[ListLogPlot, {xy, xyP, xyM, xPy, xMy}]

enter image description here



Answer



README: This answer is not correct scientifically, I just transformed error bars to log scale instead of doing a correct error propagation. Didn't have time to fix it yet :(



Here's a minimal example:


data = {{20, 100}, {30, 10}, {100, 1000}, {500, 1000}};

xer = {{10, 10}, {20, 300}, {50, 50}, {100, 200}};
yer = {{50, 50}, {5, 50}, {100, 500}, {300, 100}};

errorPlot[#, data, xer, yer] & /@ {ListPlot, ListLogPlot, 
                                   ListLogLogPlot, ListLogLinearPlot};

enter image description here


Code:


errorPlot[plot_, data_, xer_, yer_] := With[{
       tr = Transpose@data,

       arrow = Graphics[{Red, Line[{{0, 1/2}, {0, -1/2}}]}]},
      Module[{PlusMinus, limits, limitsRescaled, dataRescaled, lines, scale},

       scale = plot /. {ListPlot -> {# &, # &}, ListLogPlot -> {# &, Log}, 
                        ListLogLogPlot -> {Log, Log}, ListLogLinearPlot -> {Log, # &}};

       PlusMinus[a_, b_] := {a - b[[1]], a + b[[2]]};
       limits =  MapThread[MapThread[PlusMinus, {#, #2}] &,
                           {tr, {xer, yer}}];


       limitsRescaled = MapThread[Compose, {scale, limits}];   
       dataRescaled = MapThread[Compose, {scale, tr}];

       lines = Flatten[
                MapAt[Reverse, 
                      MapThread[{{#2[[1]], #}, {#2[[2]], #}} &, 
                                {Reverse@dataRescaled, limitsRescaled}, 2], 
                      {2, ;; , ;;}], 1];   

        Show[

         plot[data, PlotStyle -> AbsolutePointSize@7, Axes -> False, Frame -> True, 
                    BaseStyle -> 18, ImageSize -> 500],
         Graphics[{Arrowheads[{{-.02, 0, arrow}, {.02, 1, arrow}}], Thick, Arrow[lines]}]
         ,
         PlotRange -> ({Min[#], Max[#]} & /@ Transpose@Flatten[lines, 1])]]]

Comments

Post a Comment

Popular posts from this blog

mathematical optimization - Minimizing using indices, error: Part::pkspec1: The expression cannot be used as a part specification

I want to use Minimize where the variables to minimize are indices pointing into an array. Here a MWE that hopefully shows what my problem is. vars = u@# & /@ Range[3]; cons = Flatten@ { Table[(u[j] != #) & /@ vars[[j + 1 ;; -1]], {j, 1, 3 - 1}], 1 vec1 = {1, 2, 3}; vec2 = {1, 2, 3}; Minimize[{Total@((vec1[[#]] - vec2[[u[#]]])^2 & /@ Range[1, 3]), cons}, vars, Integers] The error I get: Part::pkspec1: The expression u[1] cannot be used as a part specification. >> Answer Ok, it seems that one can get around Mathematica trying to evaluate vec2[[u[1]]] too early by using the function Indexed[vec2,u[1]] . The working MWE would then look like the following: vars = u@# & /@ Range[3]; cons = Flatten@{ Table[(u[j] != #) & /@ vars[[j + 1 ;; -1]], {j, 1, 3 - 1}], 1 vec1 = {1, 2, 3}; vec2 = {1, 2, 3}; NMinimize[ {Total@((vec1[[#]] - Indexed[vec2, u[#]])^2 & /@ R...
Post a Comment
Read more

functions - Get leading series expansion term?

Given a function f[x] , I would like to have a function leadingSeries that returns just the leading term in the series around x=0 . For example: leadingSeries[(1/x + 2)/(4 + 1/x^2 + x)] x and leadingSeries[(1/x + 2 + (1 - 1/x^3)/4)/(4 + x)] -(1/(16 x^3)) Is there such a function in Mathematica? Or maybe one can implement it efficiently? EDIT I finally went with the following implementation, based on Carl Woll 's answer: lds[ex_,x_]:=( (ex/.x->(x+O[x]^2))/.SeriesData[U_,Z_,L_List,Mi_,Ma_,De_]:>SeriesData[U,Z,{L[[1]]},Mi,Mi+1,De]//Quiet//Normal) The advantage is, that this one also properly works with functions whose leading term is a constant: lds[Exp[x],x] 1 Answer Update 1 Updated to eliminate SeriesData and to not return additional terms Perhaps you could use: leadingSeries[expr_, x_] := Normal[expr /. x->(x+O[x]^2) /. a_List :> Take[a, 1]] Then for your examples: leadingSeries[(1/x + 2)/(4 + 1/x^2 + x), x] leadingSeries[Exp[x], x] leadingSeries[(1/x + 2 + (1 - 1/x...
Post a Comment
Read more

What is and isn't a valid variable specification for Manipulate?

I have an expression whose terms have arguments (representing subscripts), like this: myExpr = A[0] + V[1,T] I would like to put it inside a Manipulate to see its value as I move around the parameters. (The goal is eventually to plot it wrt one of the variables inside.) However, Mathematica complains when I set V[1,T] as a manipulated variable: Manipulate[Evaluate[myExpr], {A[0], 0, 1}, {V[1, T], 0, 1}] (*Manipulate::vsform: Manipulate argument {V[1,T],0,1} does not have the correct form for a variable specification. >> *) As a workaround, if I get rid of the symbol T inside the argument, it works fine: Manipulate[ Evaluate[myExpr /. T -> 15], {A[0], 0, 1}, {V[1, 15], 0, 1}] Why this behavior? Can anyone point me to the documentation that says what counts as a valid variable? And is there a way to get Manpiulate to accept an expression with a symbolic argument as a variable? Investigations I've done so far: I tried using variableQ from this answer , but it says V[1...
Post a Comment
Read more