faster prod(::Array{BigInt})

[rfourquet]

By having a first pass on the array to compute the size of the result
(this avoids re-allocations).

Example:

julia> xs = rand(1:big(2)^20, 20);

julia> @btime prod($xs); # master
  2.050 μs (57 allocations: 1.23 KiB)

julia> @btime prod($xs); # PR
  310.413 ns (2 allocations: 192 bytes)

[oscardssmith]

Looks great!

[vtjnash]

I'd worry slightly this has exponential memory blowup. I realize that this is already the case for multiplication generally, but if most of arr was ones or other small numbers, this seems like it would vastly over-estimate the size of the final result. Then if prod is repeated, would it double the size of the allocation again? I notice that we don't estimate the size of mul normally.

The old comment also claimed this performs the operations in a less efficient order? The benchmark you gave might be multiplying relatively few, small numbers (20) to see the advantage?

[rfourquet]

I can experiment with making an estimate at the bit level instead of the limb level, this would limit the blowup.

Then if prod is repeated, would it double the size of the allocation again?

No, as this uses x.size which is exact, and can be less than the memory which was allocated (x.alloc).

The old comment also claimed this performs the operations in a less efficient order?

The old comment (by me), didn't take into account the possibility of pre-allocating, and underestimated the cost of allocations compared to that of the multiplication. I would tend to believe that the different order was more efficient (assuming equally sized integers) at least partly because there would be less intermediate allocations.

[rfourquet]

Good to go?

[oscardssmith]

It needs a rebate, but otherwise looks good.

[DilumAluthge]

@rfourquet Can you try rebasing again on the latest master? These test failures have been fixed on master.