What is the most efficient way to add zeros to end of a number?

Question

Beside *10^n, is there a faster way to add thousands of zeros to end of a number?

Updated

Timings:

In[230]:= First[Timing[prime*10^100000000]]

Out[230]= 3.625

In[25]:= First[
 Timing[FromDigits[
   Join[IntegerDigits[prime], ConstantArray[0, 100000000]]]]]

Out[25]= 7.547

Updated

According to Mr.Wizard answer:

In[46]:= First[Timing[2213*1*^200000000]]

Out[46]= 0.015 (* The real timing on the clock is 5 seconds *)

In[45]:= First[Timing[2213*10^200000000]]

Out[45]= 5.11

In[3]:= First[Timing[ToExpression["2213*1*^200000000"]]]

Out[3]= 5.078

But the strange thing is that by using special 1*^ notation, the reported timing is almost zero while by clock it takes roughly the same time of 10^n. Maybe Timing function doesn't take Mathematica built-in notations into account.!!

Updated 2

Yet The fastest method to beat native *^10 adding zero method is by shifting, even though the improvement is very tiny.

In[16]:= First[Timing[1223*10^100000000]]

Out[16]= 2.625

In[17]:= First[Timing[BitShiftLeft[1223*5^100000000, 100000000]]]

Out[17]= 2.547

Answer 1

My original answer is incorrect -- it is preserved as a record of my own hubris. :^)

Simply, as Rojo points out, the calculation is still being done with 1*^1000, it's just being done at a different time. One may see this by manually observing the time taken for evaluation on an idle machine, or by setting this option which will print the total time taken to evaluate a Cell of code:

SetOptions[$FrontEnd, EvaluationCompletionAction -> "ShowTiming"]

The syntax n*^x is still useful when making definitions as it evaluates before the definition is made. For example, a function defined f1 = # * 1*^100000000 & will be faster in use than f2 = # * 10^100000000 & because the huge coefficient is only calculated once, but it is still calculated.

Logically, since Mathematica still runs on a binary system, a mantissa of two does not have the overhead that a decimal one has:

1*^100000000;
(* Time: 2.18 seconds *)

2^332200000;
(* Time: 0.00 seconds *)

---

There is a simple solution to this problem and it relies on a specific input form (*^):

prime = Prime @ 813580;

First[Timing[prime*10^100000000]]

First[Timing[prime*1*^100000000]]

2.106

0.

Crucially, 1*^1000 is directly interpreted by Mathematica as the number 10¹⁰⁰⁰ while 10^1000 actually calculates this number.

---

This turns out to be anything but "simple" as I cannot think of a clean way to insert exponents programmatically into the input syntax n*^exp in a manner than retains its benefit.

Hardly nice, but at least as a proof of concept one could bodge this together with $PreRead:

$PreRead = # /. 
    RowBox[{"zeros", "[", exp_, "]"}] :> 
     "1*^" <> ToString@ToExpression@exp &;

prime = Prime @ 813580;
e = 100000000;

prime*zeros[e]; // AbsoluteTiming // First

0.0110006

prime*zeros[e] === prime*1*^100000000

True

Answer 2

You could try timing this method:

FromDigits[Join[{123}, ConstantArray[0, 20]]]

12 300 000 000 000 000 000 000