With your definitions I note that difference is 0 and taf is 100. Running the summation gives a result of 3.75977112671 in around one second.

We can instead define this as an iteration from t=100 down to 0, and construct an array of appropriate values at each step. This in turn can be done explicitly or, as I'll indicate using vector convolution.

(Below is a revised version of the original. Slightly cleaner, using Nest rather than Do).

 gSum[t_, d_] := Module[
  {iter = Ceiling[101 - t], vec, row},
  row = ConstantArray[0, 2*d + 1 + 10*iter];
  row[[d + 5*iter + 1]] = 1;
  vec = Reverse@{pa1, 0, pa2, 0, pa3, p0, pb3, 0, pb2, 0, pb1};
  Range[-d, d].Nest[
    ListConvolve[vec, #] &, row, 100 - t + 1]
  ]

In[292]:= gSum[0, 100] // Timing

Out[292]={0.004000, 3.75977112671}

So that's a speed gain of two+ orders of magnitude.

I am still trying to understand you code above, and I really have difficulties. @Daniel Lichtblau

I would appreciate it, if you could spend 5 minutes to explain it in more detail. If it is much trouble though, then its ok, no need to devote more time. Anyhow, thanks again

Thank you, you are right. i really appreciate your help , i will go through what you suggest. Your clarifications are really helpfull. @Daniel Lichtblau

Thanks a lot for your assistance!

@Daniel Lichtblau : I will try to implement what you said, thanks. With respect to excel, maybe I was not clear. My original algorithm didn't involve recursive functions. I did it in excel, where I created a huge spreadsheet where each state t (0 until 100) was a column of cells whose values where calculated based on previous step. So it was really big and painful. But also really fast since it didn't involve any function calling it self. But it was really hard to maintain it, while with the recursive function f (and mathematica), it was easier for me. The slow speed apparently has to do with me not writing "correct" code. Nevertheless I appreciate your support.

@Bill Simpson I really do not understand your attitude. f is provided already, so why the irony. Nevertheless thank you too for trying to help in your own way. I appreciate it.

One way to possibly improve speed would be to recast as a double loop, iterating for t from 100 to 0 and d from something like -600 to 600 when t is 100, decreasing this range as t decreases since fewer such values will be needed. It could be done with Compile.

That said, I have to wonder what Excel might be doing to get a result instantaneously. These loops imply a complexity of O(n^2) at a minimum, where n is 100 in this case. Not huge by any means, but also not negligeable. Do you have the Excel code available?

Hi,

using parallel made it a bit faster for me. On my machine this is faster than the original (at least after the Kernels are launched).

CloseKernels[]; 
ClearAll["Global`*"]
    a1 = 0;
    a2 = 0;
    a3 = 0;
    a4 = 0;
    b1 = 0;
    b2 = 0;
    b3 = 0;
    b4 = 0;

    a = 20.50;
    b = 15.;
    pa1 = 0.0241637323943662`;
    pa2 = 0.014498239436619723`;
    pa3 = 0.0027875586854460006`;
    pb1 = 0.018726892605633805`;
    pb2 = 0.011236135563380286`;
    pb3 = 0.00216035798122065`;
    p0 = 0.9264270833333333`;

    aTotal = 5*a1 + 3*a2 + 1*(a3 + a4);
    bTotal = 5*b1 + 3*b2 + 1*(b3 + b4);
    difference = aTotal - bTotal;
    t = 0;
    taf = 100 - t;

    pa1 = 0.0241637323943662`;
    pa2 = 0.014498239436619723`;
    pa3 = 0.0027875586854460006`;
    pb1 = 0.018726892605633805`;
    pb2 = 0.011236135563380286`;
    pb3 = 0.00216035798122065`;
    p0 = 0.9264270833333333`;

    f[t_, d_] := 
      f[t, d] = 
       If[t > 100, 0, 
        If[d == difference && t == taf, 1, 
         pa1*f[t + 1, d - 5] + pa2*f[t + 1, d - 3] + pa3*f[t + 1, d - 1] +
           pb1*f[t + 1, d + 5] + pb2*f[t + 1, d + 3] + 
          pb3*f[t + 1, d + 1] + p0*f[t + 1, d]]];
    Quiet[LaunchKernels[]];
    InTime = AbsoluteTime[];
    (*expected=Sum[j*f[0,j],{j,-100,100}]*)
    expected = 
     Total[ParallelTable[j*f[0, j], {j, -100, 100}]]
    OutTime = AbsoluteTime[];
    OutTime - InTime

But there is a problem because the f function is not properly cleaned. If you rerun the program with different parameters it gives the same results unless you properly clean the function f. Mathematica obviously uses the assignments made in the first run and does not clear them even if you use ClearAll. If you clear the function and relaunch the Kernels etc. this method does not seem to help speed everything up. Perhaps it is possible to use Parallel somewhere outside of the larger structure that you describe in your code.

Have you tried compiling it?

Best wishes, M.

Hard to assess without knowing the function f[t,x]