Interpolate functionality. [feature request]

[DylanVann]

Could look like this:

interpolate(
    nodeOrValue,
    {
        inputRange: [nodeOrValue, ...],
        outputRange: [nodeOrValue, ...],
    }
)

Questions:

• Can this be implemented using existing node types?
• Can the input range actually be animated?
  • If so how do we know when to stop searching for the closest values to the input value?
  • We could just take the first value that's greater than the input value.
  • Assuming the input range always increases even if animated then it will be stable.
• How does the input range map to the output range?
  • Do we just force the arrays to be the same length and then map between them by index? This is how Animated does it.

I think a basic interpolate (interpolate(x, x0, x1, y0, y1)) could be made using existing node types.

I took a shot at implementing something using nested conds, it didn't go that well. I'll try again though, maybe with a different approach.

[kmagiera]

@DylanVann using cond is the right approach IMO. This resulting graph will have a number of nodes that is proportional to the number of elements in the inputRange but I'd expect this to be ok, as from my experience I never wanted to have more than just a few

[kmagiera]

Also assuming you use the approach with cond it is fine for the input range values to be "animated" too.

[kmagiera]

Made this one real quick. Seems to be working ok, we'd just need to add extrapolation handling and input validation:

function interpolateSingle(value, inputRange, outputRange, offset) {
  const inS = inputRange[offset];
  const inE = inputRange[offset + 1];
  const outS = outputRange[offset];
  const outE = outputRange[offset + 1];
  const progress = divide(sub(value, inS), sub(inE, inS));
  return add(outS, multiply(progress, sub(outE, outS)));
}

function interpolate(value, inputRange, outputRange, offset = 0) {
  if (inputRange.length - offset === 2) {
    return interpolateSingle(value, inputRange, outputRange, offset);
  }
  return cond(
    lessThan(value, inputRange[offset + 1]),
    interpolateSingle(value, inputRange, outputRange, offset),
    interpolate(value, inputRange, outputRange, offset + 1)
  );
}

[DylanVann]

@kmagiera Awesome! That's sort of what I was thinking as far as the nested conds, your implementation is a lot better than my attempt though.

Opened up a PR with extrapolation handling and some examples.