Given a value and an arbitrary range, finding equivalent value in other arbitrary range

Question

While strictly related to a programming project of mine, the problem in itself boils down to a math problem, as I am not sure which steps to take to produce the results i need.

I have an input value (floating point) that ranges from -1 and +1. This needs to be translated into an output value based on an arbitrary range. Let's call the output-range Omin-Omid-Omax, consisting of arbitrary values.

And yes, the word Range might not be the best one, seeing as the output range consists of three points. The reason for this is that the midpoint isn't necessarily the average of min and max, i.e. if one were to plot a curve based on the input and the desired output, the curve wouldn't be linear. The reason for Omid is to give a value that an input of 0 should result in.

How would i go about finding the corresponding value in Omin-Omid-Omax based on the input value?

PS: The Omin-Omid-Omax can be considered to be two linear ranges (Omin-Omid and Omid-Omax)

Hopefully this question makes sense. As you've probably figured, math is not my strongest suit, so I just hope that it's understandable.

Answer 1

You can use Spline Interpolation, which yields a continuous 3rd-degree polynomial function.

The function is guaranteed to be twice-differentiable (f, f' and f'' are viable functions).

This attribute will effectively give a "smooth appearance" to the original function.

---

Here is a piece of C code for any given number of points $(x_0,y_0),(x_1,y_1),...,(x_N,y_N)$:

void Spline(double x[N+1],double y[N+1], // input
            double A[N],double B[N],     // output
            double C[N],double D[N])     // output
{
    int i;

    double w[N];
    double h[N];
    double ftt[N+1];

    for (i=0; i<N; i++)
    {
        w[i] = (x[i+1]-x[i]);
        h[i] = (y[i+1]-y[i])/w[i];
    }

    ftt[0] = 0;
    for (i=0; i<N-1; i++)
        ftt[i+1] = 3*(h[i+1]-h[i])/(w[i+1]+w[i]);
    ftt[N] = 0;

    for (i=0; i<N; i++)
    {
        A[i] = (ftt[i+1]-ftt[i])/(6*w[i]);
        B[i] = ftt[i]/2;
        C[i] = h[i]-w[i]*(ftt[i+1]+2*ftt[i])/6;
        D[i] = y[i];
        printf("%f <= x <= %f : f(x) = %f(x-%f)^3 + %f(x-%f)^2 + %f(x-%f) + %f\n"
               ,x[i],x[i+1],A[i],x[i],B[i],x[i],C[i],x[i],D[i]);
    }
}

---

Here is a piece of Python code for any given number of points $(x_0,y_0),(x_1,y_1),...,(x_N,y_N)$:

class Point:
    def __init__(self,x,y):
        self.x = 1.0*x
        self.y = 1.0*y

def Spline(points):
    N   = len(points)-1
    w   =     [(points[i+1].x-points[i].x)      for i in range(0,N)]
    h   =     [(points[i+1].y-points[i].y)/w[i] for i in range(0,N)]
    ftt = [0]+[3*(h[i+1]-h[i])/(w[i+1]+w[i])    for i in range(0,N-1)]+[0]
    A   =     [(ftt[i+1]-ftt[i])/(6*w[i])       for i in range(0,N)]
    B   =     [ftt[i]/2                         for i in range(0,N)]
    C   =     [h[i]-w[i]*(ftt[i+1]+2*ftt[i])/6  for i in range(0,N)]
    D   =     [points[i].y                      for i in range(0,N)]
    return A,B,C,D

def PrintSpline(points,A,B,C,D):
    for i in range(0,len(points)-1):
        func = str(points[i].x)+' <= x <= '+str(points[i+1].x)+' : f(x) = '
        components = []
        if A[i]:
            components.append(str(A[i])+'(x-'+str(points[i].x)+')^3')
        if B[i]:
            components.append(str(B[i])+'(x-'+str(points[i].x)+')^2')
        if C[i]:
            components.append(str(C[i])+'(x-'+str(points[i].x)+')')
        if D[i]:
            components.append(str(D[i]))
        if components:
            func += components[0]
            for i in range (1,len(components)):
                if components[i][0] == '-':
                    func += ' - '+components[i][1:]
                else:
                    func += ' + '+components[i]
            print func
        else:
            print func+'0'

def Example():
    points = [Point(1,0),Point(2,1),Point(3,0),Point(4,1),Point(5,0)]
    A,B,C,D = Spline(points)
    PrintSpline(points,A,B,C,D)

---

Please note that the two pieces of code above assume $x_0 < x_1 < ... < x_N$.