Clearing numerical values in Mathematica

Question

I am working on fairly large Mathematica projects and the problem arises that I have to intermittently check numerical results but want to easily revert to having all my constructs in analytical form.

The code is fairly fluid I don't want to use scoping constructs everywhere as they add work overhead. Is there an easy way for identifying and clearing all assignments that are numerical?

EDIT: I really do know that scoping is the way to do this correctly ;-). However, for my workflow I am really just looking for a dirty trick to nix all numerical assignments after the fact instead of having the foresight to put down a Block.

Answer 1

If your assignments are on the top level, you can use something like this:

a = 1;
b = c;
d = 3;
e = d + b;

Cases[DownValues[In],
   HoldPattern[lhs_ = rhs_?NumericQ] | 
   HoldPattern[(lhs_ = rhs_?NumericQ;)] :> Unset[lhs],
3]

This will work if you have a sufficient history length $HistoryLength (defaults to infinity). Note however that, in the above example, e was assigned 3+c, and 3 here was not undone. So, the problem is really ambiguous in formulation, because some numbers could make it into definitions. One way to avoid this is to use SetDelayed for assignments, rather than Set.

Another alternative would be to analyze the names in say Global' context (if that is the context where your symbols live), and then say OwnValues and DownValues of the symbols, in a fashion similar to the above, and remove definitions with purely numerical r.h.s.

But IMO neither of these approaches are robust. I'd still use scoping constructs and try to isolate numerics. One possibility is to wrap you final code in Block, and assign numerical values inside this Block. This seems a much cleaner approach. The work overhead is minimal - you just have to remember which symbols you want to assign the values to. Block will automatically ensure that outside it, the symbols will have no definitions.

EDIT

Yet another possibility is to use local rules. For example, one could define rule[a] = a->1; rule[d]=d->3 instead of the assignments above. You could then apply these rules, extracting them as say DownValues[rule][[All, 2]], whenever you want to test with some numerical arguments.

Answer 2

Building on Andrew Moylan's solution, one can construct a Block like function that would takes rules:

SetAttributes[BlockRules, HoldRest]

BlockRules[rules_, expr_] := 
 Block @@ Append[Apply[Set, Hold@rules, {2}], Unevaluated[expr]]

You can then save your numeric rules in a variable, and use BlockRules[ savedrules, code ], or even define a function that would apply a fixed set of rules, kind of like so:

In[76]:= NumericCheck = 
  Function[body, BlockRules[{a -> 3, b -> 2`}, body], HoldAll];

In[78]:= a + b // NumericCheck

Out[78]= 5.

---

EDIT In response to Timo's comment, it might be possible to use NotebookEvaluate (new in 8) to achieve the requested effect.

SetAttributes[BlockRules, HoldRest]
BlockRules[rules_, expr_] := 
 Block @@ Append[Apply[Set, Hold@rules, {2}], Unevaluated[expr]]

nb = CreateDocument[{ExpressionCell[
     Defer[Plot[Sin[a x], {x, 0, 2 Pi}]], "Input"],
    ExpressionCell[Defer[Integrate[Sin[a x^2], {x, 0, 2 Pi}]], 
     "Input"]}];
BlockRules[{a -> 4}, NotebookEvaluate[nb, InsertResults -> "True"];]

As the result of this evaluation you get a notebook with your commands evaluated when a was locally set to 4. In order to take it further, you would have to take the notebook with your code, open a new notebook, evaluate Notebooks[] to identify the notebook of interest and then do :

BlockRules[variablerules, 
 NotebookEvaluate[NotebookPut[NotebookGet[nbobj]], 
  InsertResults -> "True"]]

I hope you can make this idea work.