SetOptions locally?

Question

Is there a way to SetOptions locally? For example, I have a Module and inside it I am doing a lot of Plots with similar options. If I do a SetOptions[Plot, ...] inside the Module, the change propagates outside. I don't like this because I have other Modules where I am doing other plots with different options.

Is there a way to do a SetOptions[Plot, ...] that only affects "local" plots (say inside a Module, but I am open to any scoping construct)? Here Plot is only an example. In general I want to set options locally for any symbol.

Internal`InheritedBlock[{Plot}, SetOptions[Plot, Frame -> True]; Plot[x, {x, 0, 1}] ] like this? — Kuba, Jan 23 '17 at 14:51
Why not cache the list returned by Options[Plot], do your custom stuff, and use SetOptions[] again at the end? — J. M.'s missing motivation, Jan 23 '17 at 14:55
@Kuba, I guess Internal`WithLocalSettings[] is also a possibility. — J. M.'s missing motivation, Jan 23 '17 at 15:06
@J.M. I just saw your comment. Yes, this is what I thought to do also. good idea :) — Nasser, Jan 23 '17 at 15:10
@J.M. Can you post an example of how to use WithLocalSettings? — a06e, Jan 23 '17 at 15:21
Yet another alternative is to create local option configurations. This method does not modify global state at all, even locally, but rather passes all necessary options explicitly as local rules. — Leonid Shifrin, Jan 23 '17 at 16:01
For the plotting problem in particular, one could define a plot theme. — Michael E2, Apr 13 '17 at 15:36
@MichaelE2 Wolfram should support an easy way to create new themes. — a06e, Apr 13 '17 at 15:47
There is also BlockOptions package in the SciDraw toolkit. WithOptions[{{Plot, {Frame->True}}}, Plot[...]] or BlockOptions[{Plot}, SetOptions[Plot, ...]; Plot[...]] — McSaks, Dec 05 '17 at 08:58

J. M.'s missing motivation · Answer 1 · 2021-01-20T07:49:40.830

Version 12.2

In version 12.2, use the new function WithCleanup[]:

With[{plotOptions = Options[Plot]}, 
     WithCleanup[SetOptions[Plot, PlotStyle -> Green], 
                 Plot[Sin[x], {x, -π, π}],
                 SetOptions[Plot, plotOptions]]]

which is a direct replacement of the older undocumented function described below.

Older versions

Usual caveats about using undocumented functions aside, here is how one might use Internal`WithLocalSettings[]:

With[{plotOptions = Options[Plot]}, 
     Internal`WithLocalSettings[SetOptions[Plot, PlotStyle -> Green], 
                                Plot[Sin[x], {x, -π, π}],
                                SetOptions[Plot, plotOptions]]]

~~but I do not think this to be any better than Nasser's proposal~~. As can be surmised from how it was used above, you can think of the three arguments of Internal`WithLocalSettings[] as three stages: setup, body, and clean-up. Carl notes in a comment below that the advantage of using this function is that any code in the first and third arguments are uninterruptible.

A more usual case for its use would be for localizing changes to system settings that are not easily accessible to SetOptions[]. Using the Wizard's code from here as an example:

With[{spopt = SystemOptions["SparseArrayOptions"]},
     Internal`WithLocalSettings[
              SetSystemOptions["SparseArrayOptions" -> {"TreatRepeatedEntries" -> 1}],
              ind = {{3, 1}, {3, 3}, {1, 3}, {2, 1}, {3, 2}, {3, 1},
                     {3, 2}, {3, 3}, {1, 3}, {3, 1}};
              val = {1, 1, 3, 0, 3, 4, 3, 1, 1, 1};
              SparseArray[ind -> val] // Normal,
              SetSystemOptions[spopt]]]
   {{0, 0, 4}, {0, 0, 0}, {6, 6, 2}}

(See also this SO thread and this example usage by Oleksandr.)

I would say using Internal\WithLocalSettingsis better than usingModule, because the first and third arguments ofInternal`WithLocalSettingsare not interruptible, and always happen. If you add aPause[10]to Nasser's example and abort the computation, you will see that thePlotStyleremainsGreen`. Also, it's convenient that the second argument is the output, so one doesn't need to store the result so that it can be returned as the output after the cleanup occurs. — Carl Woll, Jan 23 '17 at 17:11
"Also, it's convenient that the second argument is the output, so one doesn't need to store the result so that it can be returned as the output after the cleanup occurs." - that was certainly a convenient feature for me, but I definitely didn't know about the non-interruptibility. Thanks @Carl! — J. M.'s missing motivation, Jan 23 '17 at 17:22
@CarlWoll Maybe for you but if it eventually break your app you can't even complain because you used undocumented function. (the point here is to push it to System` since everyone is using it anyway). — Kuba, Jan 24 '17 at 06:32

score 17 · Answer 2 · edited Apr 13 '17 at 12:55

17

I have used several methods, including the ones in the other answers. I have found that the simplest method is Internal`InheritedBlock as it allows for temporary changes to a symbol to be made, including changes to Options. For example,

Internal`InheritedBlock[{Plot},
  SetOptions[Plot, PlotStyle -> Red, Frame -> True];
  Plot[Sin[x], {x, 0, 2 Pi}]
]
Plot[Sin[x], {x, 0, 2 Pi}]

Obviously, this has the most utility when you are making multiple plots, but this illustrates the point.

edited Apr 13 '17 at 12:55

Community

1

answered Jan 24 '17 at 04:14

rcollyer

33,976
7
92
191

2

Why don't you (not you personally ofc) document them then? Just add where it would not be a good idea to use it, if there are any problems. It is not like System` is perfect anyway. – Kuba Jan 24 '17 at 06:30
1

@Kuba not unreasonable, but not my department. – rcollyer Jan 24 '17 at 12:41
1

I have a particular project in which I want to change the options of a function locally in a ScheduledTaskObject without the options change altering subsequent calls in the FrontEnd. This solution seems to do the trick for me. – bobthechemist Apr 13 '17 at 14:07

score 12 · Answer 3 · answered Jan 23 '17 at 14:56

12

Just define your options as sequence held in a local variable.

Module[{opts = Sequence[PlotStyle -> Red, Frame -> True]},
  Plot[Sin[2 π x], {x, 0, 1}, Evaluate @ opts]]

answered Jan 23 '17 at 14:56

m_goldberg

107,779
16
103
257

2

Or use a List instead of a Sequence: opts = {PlotStyle -> Red, Frame -> True} – Bob Hanlon Jan 23 '17 at 15:18
@becko - it's shorter ... but flavor to taste. – Bob Hanlon Jan 23 '17 at 20:09
@becko - on my system (11.0.1 for Mac OS X x86 (64-bit)) the Evaluate is still needed. – Bob Hanlon Jan 23 '17 at 20:17
2

If you use With instead of Module, you can eliminate the Evaluate. – rcollyer Jan 24 '17 at 04:11

Nasser · Answer 4 · 2017-01-23T15:03:32.710

10

This is a simple solution. The idea is to save the Plot options on entry, and restore it on leaving the module to whatever it was

f := Module[{savedOpt = Options[Plot]},
  SetOptions[Plot, PlotStyle -> Green];
  Print@Plot[Sin[x], {x, -Pi, Pi}];
  SetOptions[Plot, savedOpt]
  ]

Now global Plot options are not changed. Test:

Mathematica graphics

edited Jan 23 '17 at 15:03

answered Jan 23 '17 at 14:48

Nasser

143,286
11
154
359

SetOptions locally?

4 Answers4

Linked