The most commonly used trigonometric functions are sine, cosine, arcsine, arccosine, arctangent, and atan2. Trigonometric optimization techniques for these functions fall into two categories:

• Lookup table-based approximations
• Polynomial approximations

These techniques are described in the following sections and the polynomial-based optimization techniques used by the TI Arm® Trigonometric Library are discussed.

Up until recently, lookup table-based approximations were considered faster than polynomial-based approximations. Lookup table-based approximations pre-compute N values of the target function and then index them into the table to select the two closest points and perform an interpolation between them. When using lookup table-based approximations, the accuracy can be adjusted by changing either the size of the lookup or the order of the interpolation function. However, this comes with the tradeoff of more memory usage and longer function times. This is the technique used by the Fast Math Functions in the Arm CMSIS Library where they use a table size of 512 entries to cover 0-2PI and then do a linear interpolation between the closest values.

With the inclusion of floating-point co-processors and faster clock speeds, the polynomial-based methods are now quite fast and have the added benefit of not requiring any table storage. The TI Arm Trig Library uses this method.

The first step in using polynomial approximations is to reduce the range of the input. The bigger the range needed to approximate, the higher order polynomial needed to achieve a specified level of accuracy, which means more computations and slower function performance.

The second step is to compute the approximation for the reduced range and then finally restore the range depending on which quadrant the input was originally in by using trigonometric identities.

There are a number of methods of finding the best polynomials to achieve the lowest error with the fewest terms, but the most commonly used is the minimax approximation algorithm and one version in particular: the Remez algorithm. The Remez algorithm is used to find a polynomial with the least maximum error. This polynomial is called a minimax polynomial. The minimax polynomial is what is used in our optimized trigonometric functions as it is ideal for control applications where worst-case performance is a key care-about.

This section shows how the above techniques are applied to optimize the computations for a Sin + Cos function. Sin + Cos functions are commonly used in the transforms for control algorithms where both sin and cos are needed at the same time.

The first step in using polynomial approximations is to range reduce the input so that the segment of the function that needs to be modeled is smaller. The most common range reduction for sin/cos computation is to reduce the input to the range.

Then, compute the approximation in this region and then adjust the sign depending on which quadrant the angle was in originally. Using the Chebyshev polynomials and the fact that sin(x) is an odd function and cos(x) is an even function, you will see the following:

Figure 2-1 Plot of Sine and Cosine Over the Range

If you assume that the input to the functions are limited to $[0:2\mathrm{\pi }]$ , you need to map the input value to the range $-\frac{\pi }{2}\le x\le \frac{\pi }{2}$ before implementing the approximation. This can be done with a couple simple comparisons:

A further range reduction technique can be used to limit the input to $-\frac{\pi }{4}\le x\le \frac{\pi }{4}$ using the trigonometric identities:

Which yields the following mapping for sin(x) and a similar one for cos(x):

Figure 2-2 Mapping of the Unit Circle for sin(x) for $0\le x\le 2\mathrm{\pi }$

Since you only have to model the sine cosine from $-\frac{\pi }{4}\le x\le \frac{\pi }{4}$ , you need fewer coefficients to achieve higher accuracy.

Figure 2-3 Plot of Sine and Cosine Over the Range

Table 2-1 and Table 2-2 show the coefficients for the sine and cosine approximation obtained from the Sollya program. The table shows the error expected given the range reduction and order of the polynomial. If you are trying to achieve full single precision floating-point accuracy, then you need to get to ~1e-7.

The arctangent function, and in particular, the arctangent2 function is a critical function in control applications. For example, in motor control, there may be sensors used to get the x and y position of a motor. Then, the application needs to translate that into an angular value. A standard arctan function would be called as arctan(y/x), but this loses the quadrant information as Q1 and Q3 are both positive and Q2 and Q4 are both negative. The arctan2 function accepts both the x and the y input to return a value in the full −π to π range versus the arctan function that returns values only in Q1 or Q4, −π/2 to π/2.

Figure 2-4 Plot of arctan2(y,x)

As the input to arctan(z) can be any number from −∞to ∞, use trig identities to reduce the range and get an approximation function that is relatively low complexity.

Start with:

• arctan(x) = π/2- arctan(1/x) (1a)
• arctan(x)=−arctan(x) (2a)

These identities allow you to restrict the approximation range to abs(x) <=1.

The next step is to find a simple polynomial that approximates arctan in the range 0-1, or -1 to 1. Using sollya, try some different polynomial lengths to get the approximation error. This is shown in Table 2-3. You can see that the error is not falling that fast as a function of the number of terms in the polynomial, so even at 6 terms you are still at 3.4e-6 in the range (-1,1). Also note that arctan is an odd function where all the terms are odd powers.

Table 2-3 shows the coefficients for the arctangent approximation obtained from the Sollya program. The table shows the error expected given the range reduction and order of the polynomial.

Math.h includes the standard functions for single-precision floating-point sinf(), cosf(), atanf(), and atan2f(), as well as the double-precision sin(), cos(), atan(), atan2(). These functions use polynomial-based approximation methods and provide high accuracy with no input limitations, but at the cost of more cycles. These functions are benchmarked and the results are shared at the end of this section.