32位整数缩放，无溢出

Question

Hi I have a following values:

uint32_t value = 1230000;
uint32_t max_value = 1234567;

Now, I would like to perform scaling:

uint32_t scaled = value * 1000000 / max_value;

The problem is if I use 32bit integer it will overrun for such big numbers. On the other hand I cannot use 64bit. Any idea how to properly implement mentioned scaling?

EDIT

Just to mention, I am working on STM32 - a 32-bit micro-controller, where performing 64-bit multiplication and division is extremely costly. Therefore I would like to avoid them.

Answer 1

You can do it by seeing scale as a base-1000 number: value = value_high*1000 + value_low . Calculate value_high 's and value_low 's contribution to scaled separately, storing the intermediate values as a fraction: scaled = scaled_int + scaled_remainder/max_value

uint32_t value_low = value%1000;
uint32_t value_high = value/1000;
uint32_t scaled_int, scaled_remainder;

uint32_t low = value_low * 1000000;
scaled_int = low / max_value;
scaled_remainder = low % max_value;

scaled_int += value_high * 810;  // pre-calculated 1000*1000000 / max_value
scaled_remainder += value_high * 730;  // pre-calculated 1000*1000000 % max_value
scaled_int += scaled_remainder / max_value;
scaled_remainder = scaled_remainder % max_value;

Also, you don't have to use base 1000, base 1024 might be a bit faster. As long as the 4th and 8th line don't overflow at their maximum value, it should work.

Answer 2

you can declare scaled as unsigned long long type like below & then do explicit typecast accordingly.

unsigned long long scaled = (unsigned long long)value * 1000000 / max_value; /* make either operand of unsigned long long type explicitly */
printf("%llu\n",scaled);

Answer 3

if your translater can support 64bit,then

uint32_t scaled =(uint32_t)((uint64_t)value * 1000000 / max_value);

if support float,then

uint32_t scaled =(uint32_t)(value *1.0 / max_value* 1000000);

There will be a little loss of precision.

Answer 4

The fastest way of scaling is using the 2 power scale factors.

Even you have two numbers scaled using different scale factors - the arithmetic is trivial.

example:

uint32_t scaledDiv(uint32_t a, uint32_t b, uint32_t *sclef)
{
    *sclef = __builtin_clz(a);
    a <<= *sclef;
    return a/b;
}

Answer 5

The problem is of form: value/max_1 = x/1000000 .

Without solving this in closed form, the closest x can be calculated iteratively using bisection.

 uint32_t step=max_value>>1;
 uint32_t v=0, x=0, step2=1000000/2 << 12;
 // step2 has been scaled to add extra precision
 while(step) {
    if (value > v+step) { v+=step; x+=step2; }
    step>>=1; step2>>=1;
 }
 x=(x+2048)>>12; // scale down and round

The result will finish in 32 iterations.