Hmm, just while I'm typing Matt gives the same idea. However, I don't want to waste the work of having typed this all, and at least here is it with a concrete example.
There is a very simple one. It makes use of the partial sums of the logarithmic series.
say, you've n=53 and look for m, such that $ \small 2^m<3^n<2*2^m $ .
Then $ \small m = floor(n*log(3)/log(2)) $
So if we use an appropriate power series for log(3) and log(2), and evaluate successively to higher orders we will arrive at a value, where the floor-function does no more increase.
The given example works fast because the partial evaluations converge geometrically with the index
There is a powerseries for the logarithm, which also converges for x>2. This
$$ \small
f(x,k) = 2 \cdot ( {x-1\over x+1} + ({x-1\over x+1})^3{1 \over 3} + ({x-1\over x+1})^5 {1 \over 5} + \ldots +({x-1\over x+1})^{2 k+1} {1 \over 2*k+1 } )
$$
So we have by the partial evaluations
$$ \small
\lim_{ k \to \infty} ps(k) = floor ( {f(3,k) \over f(2,k)} ) \text{ and }
m(k)=n \cdot ps(k)
$$
We arrive at m=84 at k=6
The evaluation of the powerseries is then with the terms for x=3:
$ \small {x-1\over x+1} = {1 \over 2} \text{ and } ({x-1\over x+1})^2= {1 \over 4} $
and with the terms for x=2:
$ \small {x-1\over x+1} = { 1 \over 3} \text{ and } ({x-1\over x+1})^2= {1 \over 9} $
then
$$ \small \begin{array} {rllll}
ps(1) &=& { 1/2 \over 1/3 } &=& {3 \over 2} = 1.5 \\
ps(2) &=& { 1/2 + 1/8/3 \over 1/3+1/27/3 } &=& { 13*81 \over 24*28 } \\
ps(3) &=& { 1/2 + 1/8/3 + 1/32/5 \over 1/3+1/27/3 +1/243/5 } &=& { \cdots \over \cdots } \\
\cdots& & \cdots
\end{array}
$$
Here is some Pari/GP-code:
m_by_n(n)=floor(log(3)/log(2)*n)
[n=53,m_by_n(n)] \\ have a check for the true result
\\ initialize loop:
k = 1
f3 = 1/2 f2 = 1/3
s3 = f3 s2 = f2
ps = 1.0*s3/s2 \\ this is the lower approximate of log(3)/log(2)
m_k = n * ps \\ this is our approximate of n* log(3)/log(2)
\\ loop through the following until convergence
k++
f3 /= 4 f2 /= 9
s3 += f3/(2*k1-1) s2 += f2/(2*k1-1)
ps = 1.0*s3/s2
m_k = n*ps
change_k = m_k -m_k1
m_k1 = m_k
k ps m_k change_k
------------------------------------------------------------
%211 = [1, 1.5000000, 79.500000]
%212 = [2, 1.5669643, 83.049107, 3.5491071]
%213 = [3, 1.5812797, 83.807824, 0.75871649]
%214 = [4, 1.5842020, 83.962707, 0.15488293]
%215 = [5, 1.5848024, 83.994526, 0.031819453]
%216 = [6, 1.5849281, 84.001190, 0.0066638762]
%217 = [7, 1.5849550, 84.002614, 0.0014242816]
%218 = [8, 1.5849608, 84.002924, 0.00031000195]
%219 = [9, 1.5849621, 84.002993, 0.000068520789]
we could stop at k=6 because the change is smaller than the distance to the next greater integer but its rate of decrease is stronger than 1/2
It would be even more elegant if we had a second powerseries which approximates from above, and then stop iteration when there is only one integer in between (but I didn't give this much thought).
[update]
For n which provide m with a very good approximation (that means we use convergents of the continued fraction of $ \small \log(3)/ \log(2)) $ ) we need always most series terms. In http://go.helms-net.de/math/collatz/2hochS_3hochN_V2.htm I have a table with such convergents. For the highest n documented there ( n=22431534635635487631007267235817836787 ( 38 digits), log(n)~86.0035311129 ) the algorithm needs 120 series terms while for an "average" number in the near of that number the algo need about the half number of series terms. It is perhaps of interest, that the ratios series terms/log(n) are relatively constant along the sequences of best approximations (by continued fractions) as well as for sequences of "average" approximations, if I choose one random-number n . For the best approximations this is in the near of 1.4 (in the example 120/86.0 ) and for the average approximations it is in the near of 0.7 (or just the half of series terms are required).
[update 2] This update occurs long after the question is answered just for the cursory reader. I give a better Pari/GP-implementation so you can try it immediately with different values. Also I adapted the notation to my usual conventions.
\\ code for Pari/GP
SbyN(N)=floor(log(3)/log(2)*N) \\ the reference value
{SbyN_part(N,maxit=150)=local(f3,f2,s3,s2,ps,m_k,change_k,m_k_prev);
print(" "); \\ print-cmds only for demo
f3 = 1/2 ; f2 = 1/3 ;
s3 = f3 ; s2 = f2;
ps = 1.0*s3/s2 ; \\ this is the lower approximate of log(3)/log(2)
m_k = N * ps ; \\ this is our approximate of n* log(3)/log(2)
\\ loop through the following until convergence
for(k=1,maxit,
f3 /= 4 ; f2 /= 9;
s3 += f3/(2*k+1); s2 += f2/(2*k+1);
ps = 1.0*s3/s2 ;
m_k_prev = m_k;
m_k = N*ps ;
change_k = m_k -m_k_prev ;
print([k, s2*1.0, s3*1.0, ps,
floor(m_k),min(frac(m_k),frac(m_k)-1),change_k]);
if( frac(m_k) + change_k < 1,break());
);
return(floor(m_k)); }
Try some interesting values which need either many or few iterations:
\p 200 \\ I work with 200 digits prec by default
[N1=41,m_by_n(N1),SbyN_part(N1)]
[N1=94,m_by_n(N1),SbyN_part(N1)]
[N1=253,m_by_n(N1),SbyN_part(N1)]
[N1=253+1,m_by_n(N1),SbyN_part(N1)]
[N1=190537,m_by_n(N1),SbyN_part(N1)]
[N1=190537+1,m_by_n(N1),SbyN_part(N1)]
[N1=22431534635635487631007267235817836787;m_by_n(N1);SbyN_part(N1)]
[N1=22431534635635487631007267235817836787+1;m_by_n(N1);SbyN_part(N1)]
[N1=22431534635635487631007267235817836787+2;m_by_n(N1);SbyN_part(N1)]