Filling a curve to a vertical axis

Question

I am preparing a figure for an article, and I would like very much to be able to fill a curve, but not under it, but to the vertical axis, i.e. to the left. Due to the meaning of the data I present, I cannot exchange the axes.

Here is a minimal example:

Plot[ArcCot[x], {x, 0, 1}, PlotRange -> {{0, 1.1}, {0.5, 2}}, AxesLabel -> {x, y}]

Can anyone think of a way of filling the curve to they axis? I find no mention of this kind of filling in the standard documentation.

Answer 1

Adding a line at the minimum value and shading as normal:-

min = MinValue[ArcCot[x], 0 <= x <= 1, x];
Plot[{ArcCot[x], min}, {x, 0, 1}, PlotRange -> {{0, 1.1}, {0.5, 2}}, 
 AxesLabel -> {x, y}, Filling -> {1 -> {2}}, PlotStyle -> {Automatic, None}]

Answer 2

This is my second answer, which is a rather different (and simpler) idea than my first one, namely, add a polygon that shades from a Line in the plot to a vertical axis at x = x0.

fillVertical[plot_, x0_: 0.] := plot /. Line[p_] :>
   {{Opacity[0.2], Polygon[p ~Join~ {{N @ x0, p[[-1, 2]]}, {N @ x0, p[[1, 2]]}}]}, 
    Line[p]}

The shading automatically takes the color (and other directives) from the plot styles. If the graph of a single function consists of several lines, then several polygons will be drawn and they might overlap. If the endpoints of the graph are not the extrema, then an edge of the polygon will cut through the graph.*

Example

fillVertical[
 Plot[{ArcCot[x], 0.4 Sin[10 x] + x/2, 2 - x^2/3}, {x, 0.5, 2}, 
  PlotRange -> {{0, 2.1}, {0., 2}}, AxesLabel -> {x, y}]]

**Note:* I thought about using MaxValue and MinValue, but it seemed unclear to me what the desired shading would be if the extrema do not occur at endpoints. I imagine that shading to a vertical axis would be sought only when the function is invertible (i.e., when $x$ is a function of $y$). So, for example, not the case of the sine graph shown above. It turns out fillVertical works for invertible Piecewise functions. The one below would be difficult with the standard filling options of Plot. (Observe that the extrema do occur at endpoints of Lines of the graph).

fillVertical[
 Plot[Piecewise[{{x, 0 <= x <= 1}, {3 - x, 1 < x}}], {x, 0.5, 2}, 
  PlotRange -> {{0, 2.1}, {0., 2}}, AxesLabel -> {x, y}]]

Answer 3

Some of these answers seem overcomplicated.

min = MinValue[ArcCot[x], 0 <= x <= 1, x];
Plot[{ArcCot[x]}, {x, 0, 1}, PlotRange -> {{0, 1.1}, {0.5, 2}}, 
 AxesLabel -> {x, y}, Filling -> {1 -> min}]

Edit

Frankly it is unclear to me what is wanted here. My comment is more directed toward the other answers than toward the actual question. But regarding the comment from @rm here is an example of filling to the right (if that is in fact what is required):

max = MaxValue[ArcCot[x], 0 <= x <= 1, x];
Plot[{ArcCot[x]}, {x, 0, 1}, PlotRange -> {{0, 1.1}, {0.5, 2}}, 
 AxesLabel -> {x, y}, Filling -> {1 -> max}]

Happy to delete all this if none of it is what is being sought.

Answer 4

A somewhat roundabout way (switch x,y; fill; switch x,y again):

With[{plot = Plot[ArcCot[x], {x, 0, 1}, PlotRange -> {{0, 1.1}, {0.5, 2}}, 
    AxesLabel -> {x, y}]},
 With[{pts = Cases[plot,
                   Line[p_] :> (p /. {x_Real, y_Real} :> {y, x}), 
                   Infinity]},
  Show[
   ListLinePlot[pts, Filling -> Axis] /. {x_Real, y_Real} :> {y, x}, 
   FilterRules[Options[plot], Options[Graphics]]]
  ]]

One advantage to this roundabout way is filling to the axis x = 0 when the Plot domain does not include it. Here we change the plot domain to {x, 0.5, 2}:

With[{plot = Plot[ArcCot[x], {x, 0.5, 2},
                  PlotRange -> {{0, 2.1}, {0., 2}}, AxesLabel -> {x, y}]},
 With[{pts = Cases[plot,
                   Line[p_] :> (p /. {x_Real, y_Real} :> {y, x}),
                   Infinity]},
  Show[
   ListLinePlot[pts, Filling -> Axis, AxesOrigin -> {0, 0},
     FilterRules[Options[plot], Cases[Options[ListLinePlot], Except[PlotRange -> _]]],
     Options[plot, PlotRange] /. {rx_List, ry_List} :> {rx, ry}] /.
       {x_Real, y_Real} :> {y, x},
   Options[plot, PlotRange]]
  ]]

If placing the y axis to the right is desired, then the AxesOrigin can be used with ListLinePlot (when the coordinates are switched). Something like this:

Clear[x, y];
With[{plot = Plot[ArcCot[x], {x, 0.5, 2},
    PlotRange -> {{0.4, 2.1}, {0., 2}}, AxesLabel -> {x, y}]},
 With[{pts = Cases[plot,
                   Line[p_] :> (p /. {x_Real, y_Real} :> {y, x}),
                   Infinity]},
  Show[ListLinePlot[pts, Filling -> Axis, Frame -> True, AxesOrigin -> {0, 2.1},
     FilterRules[Options[plot], Cases[Options[ListLinePlot], Except[PlotRange -> _]]],
     Options[plot, 
       PlotRange] /. {rx_List, ry_List} :> {rx, ry}] /. {x_Real, y_Real} :> {y, x},
   Options[plot, PlotRange]]
  ]]

Answer 5

If you mean to fill everything to the right of the curve (you wrote "to the right", did not you?), try this:

    RegionPlot[y > ArcCot[x], {x, 0, 1.1}, {y, 0.5, 2}, 
 AxesLabel -> {x, y}]

In response to your doubts: all this in your hands. This is without extra axes:

  RegionPlot[y > ArcCot[x], {x, 0, 1.1}, {y, 0.5, 2}, AxesLabel -> {x, y}, FrameTicks -> {Automatic, Automatic, None, None}] 

This is without off-set:

RegionPlot\[y > ArcCot\[x\], {x, 0, 1.1}, {y, 0.5, 2}, 
 AxesLabel -> {x, y}, PlotRangePadding -> 0\]][3]

This is with a blue boundary, rather than gray one:

RegionPlot[y > ArcCot[x], {x, 0, 1.0}, {y, 0.5, 2}, AxesLabel -> {x, y}, PlotRangePadding -> 0, FrameTicks -> {Automatic, Automatic, None, None}, Frame -> {True, True, False, False}, BoundaryStyle -> {Blue, Thickness[0.005]}, PlotRange -> {{-0.1, 1.1}, {-0.1, 2.1}}]

and this is, if you like to have in blue only the line ActCot[x]:

    Show[{
  RegionPlot[y > ArcCot[x], {x, 0, 1.0}, {y, 0.5, 2}, 
   AxesLabel -> {x, y}, PlotRangePadding -> 0, 
   FrameTicks -> {Automatic, Automatic, None, None}, 
   Frame -> {True, True, False, False}, 
   PlotRange -> {{-0.1, 1.1}, {-0.1, 2.1}}],
  Plot[ ArcCot[x], {x, 0, 1.0}, PlotStyle -> {Blue, Thickness[0.005]}]
  }]

Have fun!

Answer 6

Using the function that I've previously defined here, we can do this:

Clear[x, y];

p = Plot[ArcCot[x], {x, 0, 1}, PlotRange -> {{0, 1.1}, {0.5, 2}}, AxesLabel -> {x, y}];

shadeBoundedArea[p, ArcCot[1] < y < ArcCot[x]]

Answer 7

I know this thread is long time inactive, but Michael E2's excellent fillVertical function above helped me out a lot. I did need a more "density"-like fill, so I'm sharing my variant of it (using my novice-level Mathematica programming skills) which splits the Line into monotonic segments:

fillVertical2[plot_, x0_: 0.] := plot /. Line[p_] :>
  Function[{mp},{{Opacity[0.2],
      Polygon[mp ~Join~ {{N@x0, mp[[-1, 2]]}, {N@x0, mp[[1, 2]]}}]}, Line[mp]}] /@ 
  SequenceCases[p, lp_ /; Less @@ lp[[All, 2]] || Greater @@ lp[[All, 2]]];

This gives a plot like

fillVertical2[Plot[Sin[x] + 0.3 x, {x, 0, 10}, PlotStyle -> Red]]