Question

I have a difficult mathematical question that is breaking my brain, my whiteboard, and all my pens. I am working with a file that expresses 2 values, a multiplicand and a percentage. Both of those values must be integers. These two values are multiplied together to produce a range. Range is a float value.

My users edit the range, and I have to calculate a new percentage and multiplicand value. Confused yet? Here’s an example:

    Multiplicand: 25000 Apples
    Percentage: 400 (This works out to .4% or .004)
    Range: 100.0 Apples (Calculated by Multiplicand * Percentage)

To complicate things, the allowable values for Percentage are 0-100000. (Meaning 0-100%) Multiplicand is a value between 1 and 32bit int max (presumably unsigned).

I need to allow for users to input a range, like so:

Range: .04 Apples

And calculate the appropriate Percentage and Multiplicand. Using the first example:

    OriginalMultiplicand: 25000 Apples
    OriginalPercentage: 400 (This works out to .4% or .004)
    OriginalRange: 100.0 Apples (Calculated by Multiplicand * Percentage)
    NewRange: .01 Apples
    NewPercentage: 40
    NewMultiplicand: 25 Apples

The example calculation is easy, all that was required was adjusting down the multiplicand and percentage down by the scale factor of the new and old range. The problem arises when the user changes the value to something like 1400.00555. Suddenly I don’t have a clean way to adjust the two values.

I need an algorithmic approach to getting values for M & P that produce the closest possible value to the desired range. Any suggestions?

Answer 1

To maximize the numbers of decimal points stored, you should use a P of 1, or 0.1%. If that overflows M, then increment P.

So for your example of 1400.00555, P is 1 and M is 1400006

Your algorithm would search for the lowest P such that M does not overflow. And you can do a binary search here.

public int binarySearch(int P0, int P1) {
   P = (P1 - P0)/2;
   if(P == P0) {
     if(R/(P0/100f) does not overflows 32-bit int) {
       return P0;
     } else {
       return P1;
     }
   }
   if(R/(P/100f) does not overflows 32-bit int) {
     return binarySearch(P0, P);
   } else {
     return binarSearch(P, P1);
   }
}

P = binarySearch(1, 100000);
M = round(R/(P/100f));