Scaling a number between two values

If I am given a floating point number but do not know beforehand what range the number will be in, is it possible to scale that number in some meaningful way to be in another range? I am thinking of checking to see if the number is in the range 0<=x<=1 and if not scale it to that range and then scale it to my final range. This previous post provides some good information, but it assumes the range of the original number is known beforehand开发者_StackOverflow.

You can't scale a number in a range if you don't know the range.

Maybe what you're looking for is the modulo operator. Modulo is basically the remainder of division, the operator in most languages is is %.

0 % 5 == 0
1 % 5 == 1
2 % 5 == 2
3 % 5 == 3
4 % 5 == 4
5 % 5 == 0
6 % 5 == 1
7 % 5 == 2
...

Sure it is not possible. You can define range and ignore all extrinsic values. Or, you can collect statistics to find range in run time (i.e. via histogram analysis).

Is it really about image processing? There are lots of related problems in image segmentation field.

You want to scale a single random floating point number to be between 0 and 1, but you don't know the range of the number?

What should 99.001 be scaled to? If the range of the random number was [99, 100], then our scaled-number should be pretty close to 0. If the range of the random number was [0, 100], then our scaled-number should be pretty close to 1.

In the real world, you always have some sort of information about the range (either the range itself, or how wide it is). Without further info, the answer is "No, it can't be done."

I think the best you can do is something like this:

int scale(x) {
    if (x < -1) return 1 / x - 2;
    if (x > 1) return 2 - 1 / x;
    return x;
}

This function is monotonic, and has a range of -2 to 2, but it's not strictly a scaling.

I am assuming that you have the result of some 2-dimensional measurements and want to display them in color or grayscale. For that, I would first want to find the maximum and minimum and then scale between these two values.

static double[][] scale(double[][] in, double outMin, double outMax) {
  double inMin = Double.POSITIVE_INFINITY;
  double inMax = Double.NEGATIVE_INFINITY;

  for (double[] inRow : in) {
    for (double d : inRow) {
      if (d < inMin)
        inMin = d;
      if (d > inMax)
        inMax = d;
    }
  }

  double inRange = inMax - inMin;
  double outRange = outMax - outMin;

  double[][] out = new double[in.length][in[0].length];
  for (double[] inRow : in) {
    double[] outRow = new double[inRow.length];
    for (int j = 0; j < inRow.length; j++) {
      double normalized = (inRow[j] - inMin) / inRange; // 0 .. 1
      outRow[j] = outMin + normalized * outRange;
    }
  }
  return out;
}

This code is untested and just shows the general idea. It further assumes that all your input data is in a "reasonable" range, away from infinity and NaN.