Concatenating integers and floating point instability

Suppose we have two integers, a and b, their concatenation may be simply calculated by:

def concat_simple(a, b):
    return int(str(a) + str(b))

This implementation is correct, but converting integers to strings and back to an integer is slow. It would be faster if we could somehow not perform any string conversions.

Mathematically, for \(b \neq 0\), the following is true: $$ concat(a, b) = a \times 10 ^ {\lfloor log_{10}b \rfloor + 1} + b $$

Translating the above into Python:

from math import log

def concat(a, b):
    if b == 0:
        return a * 10
    upper = a * 10**int(log(b, 10) + 1)
    return upper + b

>>> concat(1234, 5678)
12345678

>>> concat(100, 1000)
101000    # Incorrect!

Our concat function seems correct, but concat(100, 1000) returns 101000 rather than 1001000 — why? The reason is due to the limited precision of floating point numbers. In this case, log(1000, 10) is 2.9999999999999996, so int(log(1000, 10) + 1) returns 3 rather than 4. To handle the imprecision, we can check if upper <= a * b, and if so, multiply it by 10 to get the correct answer.

def concat(a, b):
    if b == 0:
        return a * 10
    upper = a * 10**int(log(b, 10) + 1)
    if upper <= a * b:
        upper *= 10
    return upper + b

Now concat(100, 1000) == 1001000.