Question

While learning for an exam, I’ve just found the following task in an exercise:

Write a function that gives the integer logarithm to base 2 (rounded up) while only using multiplication and addition.

I tried, immediately, but couldn’t come to any solution. I thought that would be an easy task but I could only find a solution when using integer division (e.g. in Haskell):

log2 :: Int -> Int
log2 1 = 0
log2 2 = 1
log2 x = 1 + log2 (x `div` 2)

Is this task possible with multiplication only at all? Using multiplication on the left side (pattern) always results in compiler errors. And using it on the right side, how can I trace the solution back to lower numbers?

Answer 1

And using it on the right side, how can I trace the solution back to lower numbers?

Recursion. Since it’s easier to compute the floor, we use the fact that

ceiling (log_2 n) == floor (log_2 (2*n-1))

as can easily be seen. Then to find the logarithm to the base b, we compute the logarithm to base b² and adjust:

log2 :: Int -> Int
log2 1 = 0
log2 2 = 1
log2 n
    | n < 1     = error "Argument of logarithm must be positive"
    | otherwise = fst $ doLog 2 1
      where
        m = 2*n-1
        doLog base acc
            | base*acc > m = (0, acc)
            | otherwise = case doLog (base*base) acc of
                            (e, a) | base*a > m -> (2*e, a)
                                   | otherwise  -> (2*e+1,a*base)

A simpler algorithm that needs more steps would be to simply iterate, multiplying with 2 in each step, and count, until the argument value is reached or surpassed:

log2 :: Int -> Int
log2 n
    | n < 1     = error "agument of logarithm must be positive"
    | otherwise = go 0 1
      where
        go exponent prod
            | prod < n  = go (exponent + 1) (2*prod)
            | otherwise = exponent