Re: RE: Product

```The reason for the speed of Total unlike Plus is that it does not need
to unpack packed arrays. Here is how you can see what happens.

SetSystemOptions["PackedArrayOptions" -> {"UnpackMessage" -> True}];

mytestlist = Table[RandomInteger[{1, 9}], {1000000}];
Developer`PackedArrayQ[mytestlist]
True

So mytestlist is a packed array. Now let's see what happens if we add
it up using Plus:

In[4]:= Plus @@ mytestlist
During evaluation of In[4]:= Developer`FromPackedArray::"unpack1" :
"Unpacking array."
During evaluation of In[4]:= Developer`FromPackedArray::"punpack1" :
"Unpacking array to
Out[4]= 4998322

Now the same with Total:

In[5]:= Total[mytestlist]
Out[5]= 4998322

It is the unpacking of packed arrays by Plus that makes adding up this
list using Plus much slower.
As for multiplying: I can't think of any way to multiply the elements
of a list without unpacking. However, if, as in your example, the list
contains only positive numbers the following will still beat Times
(though not by much):

Timing[b = Exp[Total[Log[mytestlist]]]; ]
During evaluation of In[3]:= Developer`FromPackedArray::"unpack1" :
"Unpacking array."
During evaluation of In[3]:= Developer`FromPackedArray::"unpack" :
"Unpacking array in call to   Log
{2.0021780000000007, Null}

while

In[4]:= Timing[a = Times @@ mytestlist; ]
During evaluation of In[4]:= Developer`FromPackedArray::"unpack1" :
"Unpacking array."
During evaluation of In[4]:= Developer`FromPackedArray::"punpack1" :
"Unpacking array to level 1
{0.30934300000000015, Null}

a == b
True

If there is a method of multiplying without unpacking it should be a
lot faster but at least at this moment I can't think of one.

Andrzej Kozlowski

On 12 Apr 2008, at 19:59, Jose Luis Gomez wrote:
> (* Steven *)
> (* I think it is an interesting question *)
> (* See what happens when we compare total with other ways to add
> many small
> integers *)
>
> (* First a test list:*)
>
> In[1]:= mytestlist = Table[RandomInteger[{1, 9}], {1000000}];
>
> (* add all the numbers in the list, and also report the computer
> time used
> to calculate:*)
>
> In[2]:= Timing[Plus @@ mytestlist]
>
> Out[2]= {0.266, 5003966}
>
> (* AGAIN add all the numbers in the list, BUT THIS TIME USING TOTAL
> and also
> report the computer time used to calculate:*)
>
> In[3]:= Timing[Total[mytestlist]]
>
> Out[3]= {0.031, 5003966}
>
> (* As you can see, for small integers, Total has a special algorithm
> that
> that adds ten times faster than just add all the numbers in order*)
> (* Therefore your question is equivalent to ask if there is an
> improved
> algorithm to multiply numbers, and if that algorithm is implemented
> in a
> special command in Mathematica, equivalent to Total*)
>
> (* I do not know the answer, while someone else answers this, you can
> multiply the following way:*)
>
> In[4]:= Times @@ mytestlist
>
> (* large result deleted *)
>
> (* The following link might be interesting for you:*)
> (* http://homepage.cem.itesm.mx/lgomez/matecmatica/fp/fp.html *)
> (* http://homepage.cem.itesm.mx/lgomez/matecmatica/funcionalprog.nb *)
>
> (* Hope that helps *)
> (* Jose *)
> (* Mexico *)
>
> -----Mensaje original-----
> De: Steven [mailto:steven_504 at telenet.be]
> Enviado el: Viernes, 11 de Abril de 2008 12:43 a.m.
> Para: mathgroup at smc.vnet.net
> Asunto: [mg87457] Product
>
> Silly beginner's question: is there a function to multiply all
> elements of a
> list, like Total does for addition?
> 'fraid I can't find it.
> TIA
>
>
>

```

• References:
• Product
• From: "Steven" <steven_504@telenet.be>
• RE: Product
• From: "Jose Luis Gomez" <jose.luis.gomez@itesm.mx>
• Prev by Date: Re: Re: what does Method->"HighDimensionalEmbedding"
• Next by Date: Re: RE: Product
• Previous by thread: RE: Product
• Next by thread: Re: Re: RE: Product