How to speed up evaluation of expression (multiple variables) to gain speed? Compile?

Question

I obtained some long expression and need to use them with a lot of different parameters inside a simulation. However, evaluation of the expressions is pretty slow, so that I would like to speed it up. The first (and only) thing that came to my mind was Compile. But, unfortunately, speed is not improved significantly.

This is an example of the shortest expression (unable to paste the larger ones because they exceed the limits on pastebin):

fun[tt_, sig_, time_, expon_, bShift_, lam_] = Uncompress@Import["https://pastebin.com/raw/nj83nT2b"];
funComp = Compile[{{tt, _Real}, {sig, _Real}, {time, _Real}, {expon, _Integer}, {bShift, _Real}, {lam, _Real}}, fun[tt, sig, time, expon, bShift, lam]];
fun[3.4, 10/4, 10, 3, 1.3456, Sqrt[2]] // AbsoluteTiming
(* {0.0836853, 0.045048} *)
funComp[3.4, 10/4, 10, 3, 1.3456, Sqrt[2]] // AbsoluteTiming
(* {0.0718691, 0.045048} *)

As you can see, Compile basically has no effect. The bigger issue is that the harmful expressions I am dealing with rather take 10s to evaluate and I'd like to see one or more orders of magnitude speed up (if possible). I hope that the small example here is essentially limited by the same effect as the bigger expressions, so that it serves as a proper toy example.

Background on fun: It essentially is composed of sums and products of Gaussians and their derivatives to higher orders (also powers of them).

Is there a way to significantly speed up the evaluation process? Potentially by more advanced usage of Compile or some other trick? Currently this is a serious bottleneck in my simulations.

Answer 1

The code for fun[tt, sig, time, expon, bShift, lam]] was not correctly inlined into the compiled function funComp. Most robust ways is to use With as follows. I also apply N to avoid some integer to double typecasts that would otherwise take place at runtime.

funComp2 = With[{code = N[fun[tt, sig, time, expon, bShift, lam]]},
   Compile[{{tt, _Real}, {sig, _Real}, {time, _Real}, {expon, _Integer}, {bShift, _Real}, {lam, _Real}},
    code,
    CompilationTarget -> "C"
    ]
   ];

(Compilation takes longer now because now there happens a lot.)

Resulting timings on my machine:

fun[3.4, 10./4, 10., 3, 1.3456, Sqrt[2.]] // AbsoluteTiming
funComp[3.4, 10/4, 10, 3, 1.3456, Sqrt[2]] // AbsoluteTiming

{0.072316, 0.045048}

{0.000197, 0.045048}

PS. You might get a further minor performance boost by changing {expon, _Integer} to {expon, _Real} because there are still some integer to double typecasts left in the C code. But that was hardly measurable with the simple test I tried so far.

PPS. You might probably want to apply this function to large lists of inputs. The the following way to compile the function (with options RuntimeAttributes -> {Listable}, Parallelization -> True) might be your friend:

funComp3 = With[{code = N[fun[tt, sig, time, expon, bShift, lam]]},
   Compile[{{tt, _Real}, {sig, _Real}, {time, _Real}, {expon, _Real}, {bShift, _Real}, {lam, _Real}},
    code,
    CompilationTarget -> "C",
    RuntimeAttributes -> {Listable},
    Parallelization -> True
    ]
   ];

Here some timing examples.

a = RandomReal[{-1, 1}, {100}];

r1 = fun[#, 10/4, 10, 3, 1.3456, Sqrt[2]] & /@ a; // RepeatedTiming // First
r2 = fun[a, 10/4, 10, 3, 1.3456, Sqrt[2]]; // RepeatedTiming // First
r3 = funComp3[#, 10/4, 10, 3, 1.3456, Sqrt[2]] & /@ a; // RepeatedTiming // First
r4 = funComp3[a, 10/4, 10, 3, 1.3456, Sqrt[2]]; // RepeatedTiming // First
errors = {Max[Abs[r1 - r2]], Max[Abs[r2 - r3]], Max[Abs[r3 - r4]]}

9.128

0.151

0.00040

0.000047

{2.60209*10^-18, 6.07153*10^-18, 0.}