1 /* ----------------------------------------------------------------------
2  * Project:      CMSIS DSP Library
3  * Title:        arm_linear_interp_f16.c
4  * Description:  Floating-point linear interpolation
5  *
6  * $Date:        23 April 2021
7  * $Revision:    V1.9.0
8  *
9  * Target Processor: Cortex-M and Cortex-A cores
10  * -------------------------------------------------------------------- */
11 /*
12  * Copyright (C) 2010-2021 ARM Limited or its affiliates. All rights reserved.
13  *
14  * SPDX-License-Identifier: Apache-2.0
15  *
16  * Licensed under the Apache License, Version 2.0 (the License); you may
17  * not use this file except in compliance with the License.
18  * You may obtain a copy of the License at
19  *
20  * www.apache.org/licenses/LICENSE-2.0
21  *
22  * Unless required by applicable law or agreed to in writing, software
23  * distributed under the License is distributed on an AS IS BASIS, WITHOUT
24  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
25  * See the License for the specific language governing permissions and
26  * limitations under the License.
27  */
28 
29 #include "dsp/interpolation_functions_f16.h"
30 
31 #if defined(ARM_FLOAT16_SUPPORTED)
32 
33 
34 /**
35   @ingroup groupInterpolation
36  */
37 
38 /**
39    * @defgroup LinearInterpolate Linear Interpolation
40    *
41    * Linear interpolation is a method of curve fitting using linear polynomials.
42    * Linear interpolation works by effectively drawing a straight line between two neighboring samples and returning the appropriate point along that line
43    *
44    * \par
45    * \image html LinearInterp.gif "Linear interpolation"
46    *
47    * \par
48    * A  Linear Interpolate function calculates an output value(y), for the input(x)
49    * using linear interpolation of the input values x0, x1( nearest input values) and the output values y0 and y1(nearest output values)
50    *
51    * \par Algorithm:
52    * <pre>
53    *       y = y0 + (x - x0) * ((y1 - y0)/(x1-x0))
54    *       where x0, x1 are nearest values of input x
55    *             y0, y1 are nearest values to output y
56    * </pre>
57    *
58    * \par
59    * This set of functions implements Linear interpolation process
60    * for Q7, Q15, Q31, and floating-point data types.  The functions operate on a single
61    * sample of data and each call to the function returns a single processed value.
62    * <code>S</code> points to an instance of the Linear Interpolate function data structure.
63    * <code>x</code> is the input sample value. The functions returns the output value.
64    *
65    * \par
66    * if x is outside of the table boundary, Linear interpolation returns first value of the table
67    * if x is below input range and returns last value of table if x is above range.
68    */
69 
70 /**
71    * @addtogroup LinearInterpolate
72    * @{
73    */
74 
75   /**
76    * @brief  Process function for the floating-point Linear Interpolation Function.
77    * @param[in,out] S  is an instance of the floating-point Linear Interpolation structure
78    * @param[in]     x  input sample to process
79    * @return y processed output sample.
80    *
81    */
arm_linear_interp_f16(arm_linear_interp_instance_f16 * S,float16_t x)82   float16_t arm_linear_interp_f16(
83   arm_linear_interp_instance_f16 * S,
84   float16_t x)
85   {
86     float16_t y;
87     float16_t x0, x1;                            /* Nearest input values */
88     float16_t y0, y1;                            /* Nearest output values */
89     float16_t xSpacing = S->xSpacing;            /* spacing between input values */
90     int32_t i;                                   /* Index variable */
91     float16_t *pYData = S->pYData;               /* pointer to output table */
92 
93     /* Calculation of index */
94     i = (int32_t) ((x - S->x1) / xSpacing);
95 
96     if (i < 0)
97     {
98       /* Iniatilize output for below specified range as least output value of table */
99       y = pYData[0];
100     }
101     else if ((uint32_t)i >= (S->nValues - 1))
102     {
103       /* Iniatilize output for above specified range as last output value of table */
104       y = pYData[S->nValues - 1];
105     }
106     else
107     {
108       /* Calculation of nearest input values */
109       x0 = S->x1 +  i      * xSpacing;
110       x1 = S->x1 + (i + 1) * xSpacing;
111 
112       /* Read of nearest output values */
113       y0 = pYData[i];
114       y1 = pYData[i + 1];
115 
116       /* Calculation of output */
117       y = y0 + (x - x0) * ((y1 - y0) / (x1 - x0));
118 
119     }
120 
121     /* returns output value */
122     return (y);
123   }
124 
125   /**
126    * @} end of LinearInterpolate group
127    */
128 
129 
130 #endif /* #if defined(ARM_FLOAT16_SUPPORTED) */
131 
132