OK, still could be improved :)

Now even more accurate with large numbers

// Example program
# include <iostream>
# include <string>


long map(long x, long in_min, long in_max, long out_min, long out_max) {
  const long out_length = out_max - out_min;
  const long in_length  = in_max - in_min;

  if (in_length == 0) { return in_min; }

  if (out_length == 0) { return out_min; }

  const long delta = x - in_min;

  if (out_length == in_length) {
    return out_min + delta;
  }

  if ((out_length < 0) && (in_length < 0)) {
    return map(x, in_max, in_min, out_max, out_min);
  } else if (out_length < 0) {
    return map(in_max - delta, in_min, in_max, out_max, out_min);
  } else if (in_length < 0) {
    return map(in_max - delta, in_max, in_min, out_min, out_max);
  }

  // We now know in_min < in_max and out_min < out_max
  // Make sure x is within range of in_min ... in_max
  if ((x < in_min) || (x > in_max)) {
    long shift_factor = 0;

    if (x < in_min) {
      const long before_min = in_min - x;
      shift_factor = -1 - (before_min / in_length);
    } else if (x > in_max) {
      const long passed_max = x - in_max;
      shift_factor = 1 + (passed_max / in_length);
    }

    if (shift_factor != 0) {
      const long in_shift  = shift_factor * in_length;
      const long out_shift = shift_factor * out_length;
      return map(x, in_min + in_shift, in_max + in_shift, out_min + out_shift, out_max + out_shift);
    }
  }

  const long abs_out_length = abs(out_length);

  if (abs_out_length > abs(in_length)) {
    const long intermediate_max = (0x2FFFFFFF - abs(in_length)) / abs_out_length;

    if (intermediate_max > (abs_out_length >> 2)) {
      const long intermediate = (delta * intermediate_max * 2 + (in_length / 2)) / in_length - intermediate_max;
      return map(intermediate, -intermediate_max, intermediate_max, out_min, out_max);
    }

    // Probably running into integer overflow, so use the slightly less accurate factor approach.
    const long factor = out_length / in_length;
    const long error_mod =  out_length % in_length;
    const long error = (delta * error_mod) / in_length;
    return (delta * factor) + out_min + error;
  }

  // abs(out_length) < abs(in_length)
  const unsigned long overflow_estimator =
    (delta > 256 ? (static_cast<unsigned long>(delta) >> 8) : 1) *
    (out_length > 256 ? (static_cast<unsigned long>(out_length) >> 8) : 1) +
    (static_cast<unsigned long>(in_length / 2) >> 8);

  if (overflow_estimator > (1u << 16)) {
    // Would result in integer overflow, so use the slightly less accurate factor approach.
    const long factor = in_length / out_length;
    const long error_mod = in_length % out_length;
    const long error = (error_mod == 0 || delta == 0) ? 0 : out_length / (delta * error_mod);

    return delta / factor + out_min + error;
  }
  return (delta * out_length + (in_length / 2)) / in_length + out_min;
}

long test_map(long x, long in_min, long in_max, long out_min, long out_max) {
  const double out_length = out_max - out_min;
  const double in_length  = in_max - in_min;

  if (in_length == 0) { return in_min; }

  if (out_length == 0) { return out_min; }

  const double delta = x - in_min;
  const double value =  (delta * out_length + (in_length / 2)) / in_length + out_min;
//  return std::round(value);    
  return value;    
}

long check(long x, long in_min, long in_max, long out_min, long out_max) {
    const long floatvalue = test_map(x, in_min, in_max, out_min, out_max);
    const long map_value = map(x, in_min, in_max, out_min, out_max);
    return floatvalue - map_value;
    
}

int main()
{
  long input = 0;

  for (size_t i = 0; i < 15; ++i) {
    input = (i / 3) * 2500 - 1 + i % 3;
    const long values[] = {
      check(input, 0,     1000,  255,      0),
      check(input, 0,     1000,  0,        255),
      check(input, 10000, 0,     100,      10100),
      check(input, 10000, 0,     10100,    100),
      check(input, 10000, 0,     0,        1024),
      check(input, 10000, 0,     1024,     0),
      check(input, 1000,  0,     0,        10240),
      check(input, 1000,  0,     10240,    0),
      check(input, 0,     1000,  0,        10240),
      check(input, 0,     1000,  10240,    0),
      check(input, 0,     10000, 10240,    0),
      check(input, 10234567, 0,  1234567,   100),
      check(input, 10000, 0,     10234567, 0),
      check(input, 50,    1,     10234567, 0)
    };
    std::cout << input << ":";
    constexpr size_t nrvalues = sizeof(values) / sizeof(values[0]);

    for (size_t i = 0; i < nrvalues; ++i) {
      std::cout << "\t" << values[i];
    }
    std::cout << "\n";
  }
}

Output:

-1:	0	0	0	0	0	0	0	1	1	0	0	-44853	2	2
0:	0	0	0	0	0	0	0	0	0	0	0	0	0	1
1:	0	0	0	0	0	0	0	0	0	0	0	0	0	0
2499:	1	0	0	0	0	0	1	0	0	1	0	418	0	0
2500:	0	0	0	0	0	0	1	0	0	1	0	419	1	0
2501:	1	0	0	0	0	0	1	0	0	1	0	419	0	1
4999:	1	0	0	0	0	0	1	0	0	1	0	-21	0	0
5000:	1	0	0	0	0	0	1	0	0	1	0	-22	1	1
5001:	1	0	0	0	0	0	1	0	0	1	0	-22	1	0
7499:	1	0	0	0	0	0	1	0	0	1	0	-32	1	1
7500:	0	0	0	0	0	0	1	0	0	1	0	-32	0	0
7501:	1	0	0	0	0	0	1	0	0	1	0	-32	1	0
9999:	1	0	0	0	0	0	1	0	0	1	0	-43	1	0
10000:	1	0	0	0	0	0	1	0	0	1	0	-44	0	0
10001:	1	0	0	0	0	0	1	0	0	1	1	-44	0	1

Description

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions