Mapping a numeric range onto another

Question

Math was never my strong suit in school :(

int input_start = 0;    // The lowest number of the range input.
int input_end = 254;    // The largest number of the range input.
int output_start = 500; // The lowest number of the range output.
int output_end = 5500;  // The largest number of the range output.

int input = 127; // Input value.
int output = 0;

How can I convert the input value to the corresponding output value of that range?

For example, an input value of "0" would equal an output value of "500", an input value of "254" would equal an output value of "5500". I can't figure out how to calculate an output value if an input value is say 50 or 101.

I'm sure it's simple, I can't think right now :)

Edit: I just need whole numbers, no fractions or anything.

Answer 1

This is GUARANTEED to map ANY range to ANY range

I wrote this method, which follows precisely the algebraic formula for mapping a number from one range to another. The calculations are done with doubles to maintain precision, then at the end, it will return a Double with however many decimal places you specify in the method arguments.

It is not necessary to name the low and high ends of a range as low or high because it makes no difference if one end is lower or higher than the other end of either range, the method will still map the number correctly.

For example, if you stated any range as [-100 to 300] or [300 to -100] it would not make any difference. The remap will still come out accurately.

Here is how you would use the method in your code:

mapOneRangeToAnother(myNumber, fromRangeA, fromRangeB, toRangeA, toRangeB, decimalPrecision)

Here is an example of how to use the method:

Source range: -400 to 800
Destination range: 10000 to 3500
Number to re-map: 250

double sourceA = -400;
double sourceB = 800;
double destA = 10000;
double destB = 3500;
double myNum = 250;
        
double newNum = mapOneRangeToAnother(myNum,sourceA,sourceB,destA,destB,2);
    
Result: 6479.17

And if you need an integer back, just pass in 0 decimal places for precision and cast the result to int like this:

int myResult = (int) mapOneRangeToAnother(myNumber, 500, 200, -350, -125, 0);

Or you could declare the method to return an int and remove the decimalPrecision argument, then change the last two lines to:

int calcScale = (int) Math.pow(10, 0);
return (int) Math.round(finalNumber * calcScale) / calcScale;

In the OPs question, they would use the function like this:

int myResult = (int) mapOneRangeToAnother(input, input_start, input_end, output_start, output_end, 0);

and here is the method:

Edit: As was pointed out by @CoryGross, if the same number is passed into the method for both end points of the from range, there will be a divide by zero. And since this method is supposed to calculate a new number based on two RANGEs of numbers, if either range has the same value for its end points, the calculated result will be meaningless, so we need to return null in that case.

This example was written in Java

public static Double mapOneRangeToAnother(double sourceNumber, double fromA, double fromB, double toA, double toB, int decimalPrecision ) {
    double deltaA = fromB - fromA;
    double deltaB = toB - toA;
    if(deltaA == 0 || deltaB == 0) {  //One set of end-points is not a range, therefore, cannot calculate a meaningful number.
        return null;
    }
    double scale  = deltaB / deltaA;
    double negA   = -1 * fromA;
    double offset = (negA * scale) + toA;
    double finalNumber = (sourceNumber * scale) + offset;
    int calcScale = (int) Math.pow(10, decimalPrecision);
    return (double) Math.round(finalNumber * calcScale) / calcScale;
}

In my use case, I needed to fade out the opacity of a JavaFX Control, but since opacity is a number from 0 to 1, I simply used the method to remap the range 1 to 100 (based on a for loop that incremented an int from 0 to 100) to the range 0 to 1 and it worked perfectly.

Though I know now that I could have created my loop by changing the increment from 1 to something like .01 like this:

for(double x=0; x<=1; x+=.01 {
    //Code to change controls opacity
}

I just pointed this out for anyone that might be doing something similar to what I was doing. The method works perfectly as described.

:-)

Answer 2

the formula is

f(x) = (x - input_start) / (input_end - input_start) * (output_end - output_start) + output_start

I'll hook up this post here: https://betterexplained.com/articles/rethinking-arithmetic-a-visual-guide/ as it helped me a lot when trying to come up with this intuitively. Once you understand what the post is saying, it's trivial to come up with these formulas on your own. Note that I used to struggle with such questions as well. (I have no affiliations - just found it very useful)

say you have range [input_start..input_end], let's start by normalising it such that 0 is input_start, and 1 is input_end. this is simple technique to make the problem easier.

how do we do that? we'll, we'd have to shift everything left by input_start amount, such that if input x happens to be input_start, it should give zero.

so, let's say f(x) is the function that does the conversion.

f(x) = x - input_start

let's try it:

f(input_start) = input_start - input_start = 0

works for input_start.

at this point, it does not work for input_end yet, as we have not scaled it.

let's just scale it down by the length of the range, then we'll have the biggest value (input_end) mapped to one.

f(x) = (x - input_start) / (input_end - input_start)

ok, let's give it a try with input_end.

f(input_end) = (input_end - input_start) / (input_end - input_start) = 1

awesome, seems to work.

okay, next step, we'll actually scale it to output range. It is as trivial as just multiplying with the actual length of the output range, as such:

f(x) = (x - input_start) / (input_end - input_start) * (output_end - output_start)

now, actually, we're almost done, we just have to shift it to right so that 0 starts from output_start.

f(x) = (x - input_start) / (input_end - input_start) * (output_end - output_start) + output_start

let's give it a quick try.

f(input_start) = (input_start - input_start) / (input_end - input_start) * (output_end - output_start) + output_start

you see that the first part of equation is pretty much multiplied by zero, thus cancelling everything out, giving you

f(input_start) = output_start

let's try input_end as well.

f(input_end) = (input_end - input_start) / (input_end - input_start) * (output_end - output_start) + output_start

which in turn will end up as:

f(input_end) = output_end - output_start + output_start = output_end

as you can see, it now seems to be mapped correctly.

Answer 3

Arduino has this built-in as map.

Example:

/* Map an analog value to 8 bits (0 to 255) */
void setup() {}

void loop()
{
  int val = analogRead(0);
  val = map(val, 0, 1023, 0, 255);
  analogWrite(9, val);
}

It also has the implementation on that page:

long map(long x, long in_min, long in_max, long out_min, long out_max)
{
  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}

Answer 4

Let's forget the math and try to solve this intuitively.

First, if we want to map input numbers in the range [0, x] to output range [0, y], we just need to scale by an appropriate amount. 0 goes to 0, x goes to y, and a number t will go to (y/x)*t.

So, let's reduce your problem to the above simpler problem.

An input range of [input_start, input_end] has input_end - input_start + 1 numbers. So it's equivalent to a range of [0, r], where r = input_end - input_start.

Similarly, the output range is equivalent to [0, R], where R = output_end - output_start.

An input of input is equivalent to x = input - input_start. This, from the first paragraph will translate to y = (R/r)*x. Then, we can translate the y value back to the original output range by adding output_start: output = output_start + y.

This gives us:

output = output_start + ((output_end - output_start) / (input_end - input_start)) * (input - input_start)

Or, another way:

/* Note, "slope" below is a constant for given numbers, so if you are calculating
   a lot of output values, it makes sense to calculate it once.  It also makes
   understanding the code easier */
slope = (output_end - output_start) / (input_end - input_start)
output = output_start + slope * (input - input_start)

Now, this being C, and division in C truncates, you should try to get a more accurate answer by calculating things in floating-point:

double slope = 1.0 * (output_end - output_start) / (input_end - input_start)
output = output_start + slope * (input - input_start)

If wanted to be even more correct, you would do a rounding instead of truncation in the final step. You can do this by writing a simple round function:

#include <math.h>
double round(double d)
{
    return floor(d + 0.5);
}

Then:

output = output_start + round(slope * (input - input_start))

Answer 5

The crucial point here is to do the integer division (which includes rounding) at the right place. None of the answers so far got the parentheses right. Here is the right way:

int input_range = input_end - input_start;
int output_range = output_end - output_start;

output = (input - input_start)*output_range / input_range + output_start;

Answer 6

output = ((input - input_start)/(input_end - input_start)) * (output_end - output_start) + output_start

What that does is find out proportionally "how far into" the input range the input is. It then applies that proportion to the size of the output range to find out in absolute terms how far into the output range the output should be. It then adds the start of the output range to get the actual output number.