I'm working on some pretty intense computation in Mathematica; when my code started running slowly, I tracked the source of the problem to Exp[]. I need to exponentiate every element of a 50x500x500 array; performing the operation on a 500x500 array takes on the order of 3 seconds (according to AbsoluteTime), so the entire array should take about 50 times that. Unfortunately, that's calculation needs to happen for every data point.

I've read about lots of ways to speed up Mathematica code, but none of those methods seem to apply here. I'm already working in MachinePrecision. I have noticed that some of my results are ridiculously small (for example, 4.282835067271648*10^-78127094), but I'm not sure how to make Mathematica ignore those; they're obviously much smaller than $MachineEpsilon.

Any advice is greatly appreciated!


Below is a sample of my code and the generated output. To give it some context, g0, is a scalar, σg0 is a length 50 array, and g is a 500x500 array.

(* Added after Oleksandr R.'s comment *)
SetSystemOptions["CatchMachineUnderflow" -> False];

n = Length[σg0];
probgs = ConstantArray[N[0], {50, 500, 500}];
For[i = 1, i <= n, i++,
  probgs[[i]] = 
    N[(1/(Sqrt[2 π] σg0[[i]])) Exp[-0.5 ((g - g0)/σg0[[i]])^2]];
  ]; // AbsoluteTiming


{4.816275, Null}

Turning off underflow definitely helped; 5 seconds isn't bad at all for what I'm doing.

  • 1
    $\begingroup$ xxx = RandomReal[{-10, 10}, {50, 500, 500}]; Exp[xxx]; takes about 0.04 seconds for me. $\endgroup$ May 8, 2013 at 10:42
  • 8
    $\begingroup$ 4.282835067271648*10^-78127094 is not a MachinePrecision number, so actually you are working in arbitrary precision. You have been caught out by automatic underflow handling, whereas clearly you would rather that such numbers go to (machine) zero. Evaluate SetSystemOptions["CatchMachineUnderflow" -> False] and try again. $\endgroup$ May 8, 2013 at 10:50
  • 5
    $\begingroup$ If you're evaluating Exp[] at very tiny arguments, you might consider replacing Exp[] with a suitably chosen Padé approximant. $\endgroup$ May 8, 2013 at 11:22
  • 3
    $\begingroup$ When dealing with probabilities, sometimes it can be more efficient to work with their natural logarithm instead of the probabilities themselves. $\endgroup$ May 8, 2013 at 11:33
  • 2
    $\begingroup$ What is \[Sigma]g0? Standalone means it should run from a fresh kernel w/o any alterations. The actual arrays matter and you cannot expect other users to bother to generate dummys. $\endgroup$
    – Yves Klett
    May 8, 2013 at 12:45

3 Answers 3


Obviously, for large negative inputs, Exp will produce very small numbers. While this isn't intrinsically problematic, it so happens that, by default, Mathematica deals with machine underflow by converting the affected values to an arbitrary precision representation in order to avoid catastrophic loss of precision. However, sometimes one would rather disregard underflowed values instead (i.e. let them go to zero), and indeed that seems to be the case here.

This behavior can be controlled using the system option "CatchMachineUnderflow"--simply use

SetSystemOptions["CatchMachineUnderflow" -> False]

and underflowed values will be flushed to (machine precision) zero.

Since this is a global option that will most likely affect the results of system functions as well as user code, it's advisable to localize its effect as tightly as possible. For this purpose one can use the undocumented function Internal`WithLocalSettings, as described by Daniel Lichtblau in this StackOverflow answer:

With[{cmuopt = SystemOptions["CatchMachineUnderflow"]},
  SetSystemOptions["CatchMachineUnderflow" -> False],
  (* put your own code here; for example: *)
(* 0.` *)

Contrast this with:

(* 5.0759588975494567652918094795743369258164499728`12.954589770191006*^-435 *)

Unfortunately, my Tarot-Cards are in repair so here is a guess:

data = yourSecertData;
pd = Developer`ToPackedArray[N[data, $MachinePrecision]];
(* must be True *)
cExp = Compile[{{in, _Real, 2}}, Exp[in], 
   RuntimeAttributes -> Listable, CompilationTarget -> "C"];

You may also want to play with the "Listable" setting and the tensor rank (2) and see if parallel execution helps, or if compilation to "C" is needed. (Maybe "WVM" is enough). If using the compiler seems helpful, may want to look up other compiler options (RuntimeOptions).


After more info was available:

cf = With[{g0 = g0}, 
  Compile[{{og0, _Real, 0}, {g, _Real, 
     2}}, (1/(Sqrt[2 \[Pi]] og0)) Exp[-0.5 ((g - g0)/og0)^2], 
   RuntimeAttributes -> Listable]]

This should speed up things considerably.

  • 5
    $\begingroup$ Compiling can be just as esoteric as the tarot cards, though :-) $\endgroup$
    – Yves Klett
    May 8, 2013 at 10:51
  • $\begingroup$ @YvesKlett, :-) lol. $\endgroup$
    – user21
    May 8, 2013 at 10:53
  • $\begingroup$ @ruebenko, I tried messing around with Compile for a while, but it complained about a pure function I had defined and, in the end, crashed my system. I never figured out what I was doing wrong, unfortunately. $\endgroup$
    – emprice
    May 8, 2013 at 11:14
  • $\begingroup$ @nosuchthingasstars, it may actually be helpful if you post that code such that this can be verified/fixed/improved. None can answer you question without seeing the code. This is like saying my bike is slow, can fix it? $\endgroup$
    – user21
    May 8, 2013 at 11:17
  • $\begingroup$ @ruebenko, I added the code just now. What I posted should run standalone. $\endgroup$
    – emprice
    May 8, 2013 at 11:20

You will save some time by computing -0.5 (g-g0)^2 just once:

probgs = With[{gg = -0.5 (g - g0)^2},
    Table[1/(Sqrt[2 Pi] sg0[[i]]) Exp[gg / sg0[[i]]^2], {i, n}]];

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.