Fixed-Point Blockset

Interpolation

In theory, you can calculate the interpolation with the following code:

• y = ( yData[iRght] - yData[iLeft] ) * ( u - xData[iLeft] )
  / ( xData[iRght] - xData[iLeft] ) + yData[iLeft]
  

The term (xData[iRght] - xData[iLeft]) is the spacing between neighboring breakpoints. If this value is constant, i.e., even spacing, some simplification is possible. If spacing is not just even but also a power of two, then very significant simplifications are possible for fixed-point implementations.

Uneven Case

For the uneven case, one possible implementation of the ideal interpolation in fixed point is as follows:

• xNum  = uAngle         - xuneven[iLeft];
  xDen  = xuneven[iRght] - xuneven[iLeft];
  yDiff = yuneven[iRght] - yuneven[iLeft];
  
  MUL_S32_S16_U16( bigProd, yDiff, xNum ); 
  
    DIV_NZP_S16_S32_U16_FLOOR( yDiff, bigProd, xDen );
  
    yUneven = yuneven[iLeft] + yDiff;
  

The multiplication and division routines are not shown here. These can be somewhat involved and depend on the target processor. For example, these routines look quite different for a 16-bit processor than for a 32-bit processor.

Even Case

Evenly spaced breakpoints implement interpolation using just slightly different calculations than the uneven case. The key difference is that the calculations do not directly use the breakpoints. This means the breakpoints are not required in ROM, which can be a very significant savings:

• xNum  = uAngle - ( iLeft * 455U );
  
    yDiff = yeven[iLeft+1] - yeven[iLeft];
  
    MUL_S32_S16_U16( bigProd, yDiff, xNum ); 
  
    DIV_NZP_S16_S32_U16_FLOOR( yDiff, bigProd, 455U );
  
    yEven = yeven[iLeft] + yDiff;
  

Power of Two Case

Power of two spaced breakpoints implement interpolation using very different calculations than the other two cases. Like the uneven case, breakpoints are not used in the generated code and therefore not required in ROM:

• lambda = uAngle & 0x00FFU;
  
    yPow2 = ypow2[iLeft)+1] - ypow2[iLeft];
  
    MUL_S16_U16_S16_SR8(yPow2,lambda,yPow2);
  
    yPow2 += ypow2[iLeft];
  

This implementation has very significant advantages over the uneven and even implementations. The key difference is that a subtraction and a division are replaced by a bitwise-AND combined with a shift right at the end of the multiply. Another advantage is that the term (u - xData[iLeft] ) / ( xData[iRght] - xData[iLeft]) is computed with no loss of precision, because the spacing is a power of two. In contrast, the uneven and even cases usually introduce rounding error in this calculation.

Determining Input Location

Conclusion