如何有效地移动数字中的小数点直到达到某个阈值

Question

Say I have a double x, whose value is > 0 and < 1 million. I want to move its decimal point left until it is > 1 million and < 10 million. So for example, 23.129385 becomes 2313938.5.

What I'm doing now is just multiplying by 10 until reaching the stopping condition. However I'm performing this algorithm a lot so if I can optimize it somehow it would be helpful. A constant time solution, irrelevant of the magnitude of x, is obviously ideal but so far I haven't been able to come up with one.

Answer 1

Some languages, such as C++ with frexp , expose the binary exponent as an integer very cheaply.

If you are so lucky you can have a precomputed lookup table pow2to10 from the 2k possible binary exponents to the power of 10 that it could be. Have another lookup table lookup10 for the powers of 10. Now your computation looks like:

frexp(x , &n);
int i = pow2to10[n];
if (lookup10[i+1] <= x) {
    i++;
}
double result = x * lookup10[i];

Now instead of a series of multiplications, you have 3 array lookups, one comparison and one multiplication. If you are executing this in a tight loop, store pow2to10 as an array of short int , try to trim the ranges to what you need, and the lookups will be in a data structure that can fit in L1 cache.

If you are not so lucky, you can instead of repeatedly multiplying, just compare against an array of known powers of 10. Be warned that if you've got a high level language, you may find that the overhead of running instructions beats the savings of comparison vs multiply. It may be tempting to do a binary search to do less lookups, but I would bet on linear search being better because that helps branch prediction.

Answer 2

You don't say which language or which type of CPU, or how the numbers are distributed (eg if most of them are less than 5 but rarely a few are large, or..); however...

The fastest scalar version I can think of (assuming C and modern 80x86 CPUs maybe) is:

    // x is between 1 and 999999

    unsigned long x_int = x;        // Integer comparisons are possibly faster
    double multiplier;

    if(x_int < 1000) {
        // x is between 1 and 999
        if(x_int < 100) {
            // x is between 1 and 99
            if(x_int < 10) {
                // x is between 1 and 9
                multiplier = 1000000;
            } else {
                // x is between 10 and 99
                multiplier = 100000;
            }
        } else {
            // x is between 100 and 999
            multiplier = 10000;
        }
    } else {
        // x is between 1000 and 999999
        if(x_int < 10000) {
            // x is between 1000 and 9999
            multiplier = 1000;
        } else {
            // x is between 10000 and 999999
            if(x_int < 100000) {
                // x is between 10000 and 99999
                multiplier = 100;
            } else {
                // x is between 100000 and 999999
                multiplier = 10;
            }
        }
    }
    x *= multiplier;

This adds up to 2 or 3 branches and one multiplication per value. Note: for modern 80x86 the final branch can be replaced with a CMOVcc instruction.

If you're doing this a lot; then the next step would be to try to use SIMD to do multiple values at the same time (followed by multi-threading/multi-CPU).