Question

In Mathematica, do I have to use an explicit loop to calculate the product of elements in a given list (potentially very long) modulo to another number?

Please teach me your elegant approach if you do have. Thanks!

Edit

Just to give an example

list=Range[2000];Mod[Product[list],32327]

The above is very inefficient, because while calculating the products, one could have taken the modulo to make the multipliers smaller.

Edit 2

I guess my question relates to how to replace for loop for

Module[{ret = initial_value}, For[i = 1, i <= Length[list], i++, ret = general_function[list[[i]],ret]; ret]

given a general function general_function and a list list.

Answer 1

For long lists a divide-and-conquer is typically faster. The idea is to compute the times-mod for the first and second halves, multiply that, and take the mod.

Here is an example. We’ll use a list of 10^6 integers, all between 0 and 10^10.

SeedRandom[1111111];
len = 6;
max = 10;
list = RandomInteger[10^max, 10^len];

Multiplying and taking the modulus, for a slightly larger mod (I wanted to decrease the likelihood that the result was zero):

In[119]:= Timing[Mod[Times @@ list, 32327541]]

Out[119]= {1.360000, 8826597}

Here is a variant of the sort I described. Trial and error tuning indicated that lists of length 2^9 or so were best done nonrecursively, at least for numbers in the size range indicated above.

tmod2[ll_List, m_] := With[{len=Floor[Length[ll]/2]},
  If[len<=256,
    Mod[Times @@ ll, m],
    Mod[tmod2[Take[ll,len],m] * tmod2[Drop[ll,len],m], m]]]

In[120]:= Timing[tmod2[list, 32327541]]

Out[120]= {0.310000, 8826597}

When I increase the list length to 10^7 and allow ints from 0 to 10^20, the first method takes 50 seconds and the second one takes 5 seconds. So clearly the scaling is working to our advantage.

For situations where an iteration interleaving two operations might be preferred to divide-and-conquer, one might use Fold as below.

tmod3[ll_List, m_] := Fold[Mod[#1*#2,m]&, First[ll], Rest[ll]]

While not competitive with tmod2 on long lists, this is faster than multiplying out everything prior to invoking Mod. For length 10^7 and max element 0f 10^20 it takes around 8 seconds to do what tmod2 did in 5.