• 1 Introduction
• 2 Probability and its rules
• 3 Combinatorics : counting evolved
• 4 Examples
• 5 Summary

1 Introduction

When it comes to math, one of the things that people are phenomenally
bad at – aside from the obvious everything – is
probabilities. Specifically, calculating probabilities.
People are bad enough at
estimating chances, but properly calculating then has its own
hurdles.

In this particular case, I’d like to take a look at the probability of
a Simple random sample: getting a particular distribution
of results from a number of samples, like getting 3 sixes in a
certain number of rolls. Specifically, I’ll look at the case
with replacement. In this case, the sample pool remains the same
after each individual sample. The case without replacement
(like picking colored marbles from a vase without putting them back)
is a bit trickier so I won’t cover that now.

The binomial distribution

One of the equations that is relevant here is the
binomial distribution
(see Eq 1), the scourge of math students
everywhere. What I’d like to do is explain why it looks the way it does,
what the terms mean and how you can generalize it to cover more than
two outcomes (that’s what the “bi-” stands for: two).
Basically, I’d like to show you how to “read” the equation
and to interpret the terms in it, which will make it easier to deal
with the subject.

(1)	title="P(W=k) = {n\choose k} p^k (1-p)^{n-k}" alt="P(W=k) = {n\choose k} p^k (1-p)^{n-k}" />

First, a few words about the Eq 1 itself. Say you have
a random event that can have two outcomes: coin-flip, true/false question,
but also a die-roll if you just look at an X vs non-X result. Or, in
the parlance of our times, whether you have a win (W) or a
fail (F). What Eq 1 gives you is the probability
of getting exactly k wins in n trials.

That’s all well and good, of course, but unless you actually understand
how the equation is built up and what all the terms in it mean, it’ll
just be yet another magic formula that someone dreamed up to torture you
with. In practical terms, it also means that it’s harder to apply it
correctly. So let’s look at what it means, starting with what each
individual symbol means.

Gaddammit!

So here I am, looking forward to a nice quiet weekend; hang
back, watch some telly and maybe read a bit – but
NNnnneeeEEEEEUUUuuuuuuuu!! Someone had to write an interesting
article about sine approximation.
With a challenge at the end. And using an inefficient kind
of approximation. And so now, instead of just relaxing, I have to spend
my entire weekend and most of the week figuring out a better way
of doing it. I hate it when this happens >_<.

Okay, maybe not.

Sarcasm aside, it is an interesting read. While the standard way of
calculating a sine – via a look-up table – works and
works well, there’s just something unsatisfying about it. The
LUT-based approach is just … dull.
Uninspired. Cowardly. Inelegant.
In contrast, finding a suitable algorithm for it requires effort and a
modicum of creativity, so something like that always piques my interest.

In this case it’s sine approximation. I’d been wondering about that
when I did my arctan article,
but figured it would require too many terms to really be worth
the effort. But looking at Mr Schraut’s post (whose site you should be
visiting from time to time too; there’s good stuff there) it seems
you can get a decent version quite rapidly. The article centers around
the work found at
devmaster thread
5784, which derived the following two equations:

(1)	title="\begin{eqnarray} S_2(x) &=& \frac4\pi x - \frac4{\pi^2} x^2 \\ \\ S_{4d}(x) &=& (1-P)S_2(x) + P S_2^2(x) \end{eqnarray}" alt="\begin{eqnarray} S_2(x) &=& \frac4\pi x - \frac4{\pi^2} x^2 \\ \\ S_{4d}(x) &=& (1-P)S_2(x) + P S_2^2(x) \end{eqnarray}" />

These approximations work quite well, but I feel that it actually
uses the wrong starting point. There are alternative approximations
that give more accurate results at nearly no extra cost in
complexity. In this post, I’ll derive higher-order alternatives for
both. In passing, I’ll also talk about a few of the tools that can
help analyse functions and, of course, provide some source code and
do some comparisons.

• 1 Theory
• 2 Derivations and implementations
• 3 Testing
• 4 Summary and final thoughts

1 Theory

1.1 Symmetry

The first analytical tool is symmetry. Symmetry is actually one of the
most powerful concepts ever conceived. Symmetry of time leads to the
conservation of energy; symmetry of space leads to conservation of
momentum; in a 3D world, symmetry of direction gives rise to the
inverse square law. In many cases, symmetry basically defines the kinds
of functions you’re looking for.

One kind of symmetry is parity, and functions can have parity as well.
Take any function f(x). A function is even if
f(−x) = f(x); it is odd
if f(−x) = −f(x).

This may not sound impressive, but a function’s parity can be a great
source of information and a way of error checking. For example, the
product of two odd or even functions is an even function, and an
odd-even product is odd (compare positive/negative number products).
If in a calculation you notice this doesn’t hold true, then you know
there’s an error somewhere.

Symmetry can also significantly reduce the amount of work you need
to do. Take the next sum, for example.

(2)	title="y = \int_{-N}^N sin^7(x^3) + \frac{x^5}{x^2+1} - x e^{\frac{x^2}{2\sigma^2}} dx" alt="y = \int_{-N}^N sin^7(x^3) + \frac{x^5}{x^2+1} - x e^{\frac{x^2}{2\sigma^2}} dx" />

If you find something like this in the wild on on a test, your first
thought might be “WTF?!?” (assuming you don’t run away
screaming). As it happens, y = 0, for reasons of symmetry. The
function is odd, so the parts left and right of x = 0 cancel out.
Instead of actually trying to do the whole calculation, you can just
write down the answer in one line: “0, cuz of symmetry”.

Another property of symmetrical functions is that, if you break them
down into series expansions, odd functions will only have odd terms,
and even functions only have even terms. This becomes important in
the next subsection.

1.2 Polynomial and Taylor expansions

Every function can be broken down into a sum of more manageable
functions. One fairly obvious choice for these sub-functions is
increasing powers of x: polynomials. The most common of
these is Taylor series, which uses
a reference point (a, f(a)) and extrapolates
to another point some distance h away by using the
derivatives of f at the reference point. In equation form,
it looks like this:

(3)

title="\begin{eqnarray} f(a+h) &=& f(a) + f'(a) h + \frac{f''(a)}{2}h^2 + \frac{f'''(a)}{6} h^3 + ... \\ \\ \\ &=& \sum_{n=0} \frac{f^{(n)}(a)}{n!}h^n \end{eqnarray}" alt="\begin{eqnarray} f(a+h) &=& f(a) + f'(a) h + \frac{f''(a)}{2}h^2 + \frac{f'''(a)}{6} h^3 + ... \\ \\ \\ &=& \sum_{n=0} \frac{f^{(n)}(a)}{n!}h^n \end{eqnarray}" />

Chances are you’ve actually used part of the Taylor series in game
programming. On implementing movement with acceleration, you’ll
often see something like Eq 4. These are the
first three terms of the Taylor expansion.

(4)	title="x_{new} = x_{old} \:+\: v \Delta t \:+\: \frac12 a (\Delta t)^2" alt="x_{new} = x_{old} \:+\: v \Delta t \:+\: \frac12 a (\Delta t)^2" />

Ihe step-size (h in Eq 3 and
Δt in Eq 4) is small, the
higher-order terms will have less effect on the end result. This
allows you to cut the expansion short at some point. This leaves
you with a short equation that you do the calculations with and
some sort of error term, composed of the part you have removed.
The error term is usually linked to the order you’ve truncated
the series at; the higher the order, the more accurate the
approximation.

(5)	title="f(a+h) = f(a) + f'(a) h + \frac{f''(a)}{2}h^2 + \frac{f'''(a)}{6} h^3 + O(h^4)" alt="f(a+h) = f(a) + f'(a) h + \frac{f''(a)}{2}h^2 + \frac{f'''(a)}{6} h^3 + O(h^4)" />

If you work out the math for a sine Taylor series, with a = 0
as the reference point, you end up with Eq 6.

(6)	title="sin(h) = h \,-\, \frac16 h^3 \,+\, \frac1{5!} h^5 \,-\, \frac1{7!} h^7 \,+\, ..." alt="sin(h) = h \,-\, \frac16 h^3 \,+\, \frac1{5!} h^5 \,-\, \frac1{7!} h^7 \,+\, ..." />

Note that all the even powers are conspicuously absent. This is what
I meant by symmetry being useful: a sine function is odd, therefore
only odd terms are needed in the expansion. But there’s more to it
than that. The accuracy is given by the highest order in the
approximating polynomial. This shows that there’s just no point in even
starting with any even-powered polynomial, because you can get one extra
order basically for free!

This is why using a quadratic approximation for a sine is somewhat
useless; a cubic will have two terms as well, and be more accurate to
boot. Just because it’s curved doesn’t mean a parabola is the most
suitable approximation.

1.3 Curve fitting (and a 3rd order example)

Using the Taylor series as a basis for a sine approximation is nice,
but it also has a problem. The series is meant to have an infinite
number of terms and when you truncate the series, you will lose
some accuracy. Of course, this was to be expected, but this isn’t
the real problem; the real problem is that if your function
has some crucial points it must pass through (which is
certainly true for trigonometry functions), the truncation will
move the curve away from those points.

To fix this, you need to use a polynomial with as-yet unknown
coefficients (that is, multipliers to the powers) and a set of
conditions that need to be satisfied. These conditions will determine
the exact value of the coefficients. The Taylor expansion can serve
as the basic for your initial approximation, and the final terms
should be pretty close to the Taylor coefficients.

Let’s try this for a third-order (cubic) sine approximation.
Technically, a third-order polynomial means four unknowns, but,
since the sine is odd, all the coefficients for the even powers
are zero. That takes care of half the coefficients already. I told
you symmetry was useful :). The starting polynomial is
reduced to Eq 7, which has two coefficients
a and b that have to be determined. For good measure
I’ve also added the derivative, as that’s often useful to have as
well.

(7)	title="\begin{eqnarray} S_3(x) &=& ax - b x^3 &=& x (a - b x^2) \\ S_3'(x) &=& a - 3bx^2 \end{eqnarray}" alt="\begin{eqnarray} S_3(x) &=& ax - b x^3 &=& x (a - b x^2) \\ S_3'(x) &=& a - 3bx^2 \end{eqnarray}" />

Two unknowns means we need two conditional to solve the system.
The most useful conditions are usually the behaviour at the
boundaries. In the case of a sine, that means look at x = 0
and/or x = ½π. The latter happens to be more
useful here, so let’s look at that. First, sin(½π) = 1,
so that’s a good one. Also, we know that at ½π a sine is
flat (a derivative of 0). This is the second condition.

The conditions are listed in Eq 8. Solving this
system is rather straightforward and will give you values for
a and b, which are also given in Eq 8.
Notice that the values are roughly 5% and 30% away from the pure
Taylor coefficients.

(8)

title="\left. \begin{eqnarray} S_3(\frac{\pi}2) &=& 1 &=& \frac{\pi}2 a - (\frac{\pi}2)^3 b \\ S_3'(\frac{\pi}2) &=& 0 &=& a - 3(\frac{\pi}2)^2 b \end{eqnarray} \; \; \rightarrow \; \; \begin{eqnarray} a &=& \frac3\pi &\approx& 0.955 \\ \\ b &=& \frac4{\pi^3} &\approx& 0.129 \end{eqnarray}" alt="\left. \begin{eqnarray} S_3(\frac{\pi}2) &=& 1 &=& \frac{\pi}2 a - (\frac{\pi}2)^3 b \\ S_3'(\frac{\pi}2) &=& 0 &=& a - 3(\frac{\pi}2)^2 b \end{eqnarray} \; \; \rightarrow \; \; \begin{eqnarray} a &=& \frac3\pi &\approx& 0.955 \\ \\ b &=& \frac4{\pi^3} &\approx& 0.129 \end{eqnarray}" />

The final equation is then:

(9)	title="S_3(x) = \frac3\pi x - \frac4{\pi^3} x^3" alt="S_3(x) = \frac3\pi x - \frac4{\pi^3} x^3" />

In Fig 1 you can see a number of different
approximations to the sine. Note that I’ve done a little coordinate
transformation for the x-axis: z = x/(½π),
so z = 1 means x = ½π. The benefit of this
will become clear later.

As you can see, the third order Taylor expansion starts out all-right,
but veers off course near the end. In contrast, the third-order fit
matches the sine at both end points. There is also the second-order
fit from the devmaster site. As you can see, the third-order approximation
is closer.

Fig 1.

Now, please remember that coefficients from Eq 8
are not the only ones you can use. The conditions define what the
values will be; different conditions lead to different values. For
example, instead using the derivative at ½π, I could have
used it at x = 0. This forms the
set of equations of Eq 10 and, as you can see,
the coefficients are now different. This set is actually more accurate
(a 0.6% average error instead of 1.1%), but it also has some rather
unsavoury characteristics of having a maximum that’s not at
½π and goes over 1.0; this can be really unsettling
if you intend to use the sine in something like rotation.

(10)

title="\left. \begin{eqnarray} S_3(\frac{\pi}2) &=& 1 &=& \frac{\pi}2 a - (\frac{\pi}2)^3 b \\ S_3'(0) &=& 1 &=& a \end{eqnarray} \; \; \rightarrow \; \; \begin{eqnarray} a &=& 1 \\ \\ b &=& \frac4{\pi^2}(1-\frac2\pi) \approx 0.147 \end{eqnarray}" alt="\left. \begin{eqnarray} S_3(\frac{\pi}2) &=& 1 &=& \frac{\pi}2 a - (\frac{\pi}2)^3 b \\ S_3'(0) &=& 1 &=& a \end{eqnarray} \; \; \rightarrow \; \; \begin{eqnarray} a &=& 1 \\ \\ b &=& \frac4{\pi^2}(1-\frac2\pi) \approx 0.147 \end{eqnarray}" />

1.4 Dimensionless variables and coordinate transformations

For higher accuracy, a higher-order polynomial should be used. Before
doing that, though, I’d like to mention one more trick that can make your
mathematical analysis considerably easier: dimensionless variables.

The problem with most quantities and equations is units. Metres, feet, litres,
gallons; those kinds of units. Units suck. For one, there are different
units for identical quantities which can be a total pain to convert
and can sometimes lead to disaster.
Literally.

Then there’s the fact that the unit sizes are basically picked at random
and have nothing to do with the physical situation they’re used for.
So you have weird values for constants like G in
Newton’s law of universal gravitation, the speed of
light c and the Planck constant, h. Keeping
track of these things in equations is annoying, especially since they
tend to pile up and everybody would rather that they’d just go
away!

Enter dimensionless variables. The idea here is that instead of using
standard units, you express quantities as ratios to some meaningful
size. For example, in relativity you often get v/c :
velocity over speed of light. Equations become much simpler if you
just denote velocities as fractions of the speed of light:
β = v/c. Using β in the equations simplifies
them immensely and has the bonus that you’re not tied to any
specific speed-unit anymore.

The dimensionless variable is a type of coordinate transformation.
In particular, it’s a scaling of the original variable into something
more useful. Another useful transformation is translation: moving
the variable to a more suitable position. We will come accross this
later; but first: an example of dimensionless variables.

A sine wave has lots of symmetry lines, all revolving around the
quarter-circles. Because of this, the term that keeps showing up
everywhere is ½π. This is the characteristic size of
the wave. By using z = x/(½π), all those
important points are now at integral z values. Having ones
in your equations is generally a good thing because they tend to
disappear in multiplications. Look at what Eq 9
becomes when expressed in terms of z

(11)

title="\begin{eqnarray} S_3(x) &=& \frac3\pi x - \frac4{\pi^3} x^3 \\ \\ &=& \frac32 \frac{2x}\pi - \frac12 (\frac{2x}\pi)^3 \\ \\ &=& \frac12 z - \frac12 z^3 \\ \\ S_3(z) &=& \frac12z (3 - z^2) \end{eqnarray}" alt="\begin{eqnarray} S_3(x) &=& \frac3\pi x - \frac4{\pi^3} x^3 \\ \\ &=& \frac32 \frac{2x}\pi - \frac12 (\frac{2x}\pi)^3 \\ \\ &=& \frac12 z - \frac12 z^3 \\ \\ S_3(z) &=& \frac12z (3 - z^2) \end{eqnarray}" />

Doesn’t that look a lot nicer? It goes deeper than that though.
With dimensionless units, the units your measurements are in simply
cease to matter! For angles, this means that whether you’re working in
radians, degrees or brads, they’ll all result in the same circle-fraction,
z. This makes converting algorithms to fixed-point notation
considerably easier.

2 Derivations and implementations

In the section above, I discussed the tools used for analysis and
gave an example of a cubic approximation. In this section I’ll also
derive high-accuracy fourth and fifth order approximations and
show some implementations. Before that, though, there’s some
terminology to go through.

Since multiple different approximations will be covered, there needs
to be a way to separate all of them. In principle, the sine
approximation will be named S_n, where n is
the order of the polynomial. So that’ll give S₂ to
S₅. I will also use S_4d for the
fourth-order approximation from devmaster. In the derivation of my
own fourth-order function, I’ll use C_n, because
what will actually be derived is a cosine.

Third-order implementation

Let’s start with finishing up the story of the third-order
approximation. The main equation for this is Eq 11.
Because this equation is still rather simple, I’ll make this a fixed-point
implementation. The main problem with turning a floating-point function
into a fixed-point one is keeping track of the fixed-point during the
calculations, always making sure there’s no overflow, but no underflow
either. This is one of the reasons why I wrote Eq 11
like it is: by using nested parentheses you can maximize the accuracy
of intermediate calculations and possibly minimize the number of
of intermediate calculations and possibly minimize the number of
operations to boot.

To coorectly account for the fixed-point positions, you need to
be aware of the following factors:

• The scale of the outcome (i.e., the amplitude): 2^A
• The scale on the inside the parentheses: 2^p. This is
  necessary to keep the multiplications from overflowing.
• The angle-scale: 2ⁿ. This is basically the value of
  ½π in the fixed-point system. Using x for the
  angle, you have  = x/2ⁿ.

Filling this into Eq 11 will give the following:

(12)

title="\begin{eqnarray} S_3(y) &=& \frac12 z (3 - 4z^2) 2^A \\ &=& z (3\cdot2^p - z^2 2^p) 2^{A-p-1} \\ &=& x (3\cdot2^p - x^2 2^{p-2n}) 2^{A-p-n-1} \\ &=& x (3\cdot2^p - x^2 / 2^r ) \middle/ 2^s, \end{eqnarray}" alt="\begin{eqnarray} S_3(y) &=& \frac12 z (3 - 4z^2) 2^A \\ &=& z (3\cdot2^p - z^2 2^p) 2^{A-p-1} \\ &=& x (3\cdot2^p - x^2 2^{p-2n}) 2^{A-p-n-1} \\ &=& x (3\cdot2^p - x^2 / 2^r ) \middle/ 2^s, \end{eqnarray}" />

with r = 2n−p and
s = n+p+1−A. These represent the
fixed-point shifts you need to apply to keep everything on the level.
With p as high as multiplication with x will allow and the
standard libnds units leads to the following numbers.

Fig 2.

That’s the calculation necessary for the first quadrant, but the domain
of a sine is infinite. To get the rest of the domain, you can use
the symmetries of the sine: the 2π periodicity and the
½π mirror symmetries. The first is taken care of by doing
z % 4. This reduces the domain to the four quadrants of a
circle. The next part is somewhat tricky, so pay attention.

Look at Fig 2. S₃ works for
quadrant 0. Because it’s antisymmetric, it will also correctly
calculate quadrant 3, which is equivalent to quadrant −1.
Quadrants 1 and 2 are the problem. As you can see in
Fig 2, what needs to happen is for those
quadrants to mirror onto quadrants 0 and −1. A reflection
of x at D is defined by Eq 13.
In this case, that means that z = 2 − z

(13)	title="x = D - (x-D) = 2D-x" alt="x = D - (x-D) = 2D-x" />

Some test need to be done to see when the reflection should take
place. The quadrant numbers in binary are 00, 01, 10, 11. If you
build a truth-table around that, you’ll see that a XOR of the
two bits will do the trick. If you really want to show off,
you can combine the periodicity modulo and the quadrant test by
doing the arithmetic in the top bits. The implementation is
now complete.

And, of course, there’s an assembly version as well. It’s only ten
instructions, which I think is actually shorter than a LUT+lerp
implementation.

Radians?

Oh wait, the requirement was for the input to be in Q12 radians,
right? Weeell, that’s no biggy. You just have to do the
x → z conversion yourself. Take, say,
2²⁰/(2π). Multiply x by this gives z
as a Q30 number; exactly what the first line in the C code resulted in.
This means that all you have to do is change the first line to
`x *= 166886;‘.

NDS special

The assembly version given above uses standard ARM instructions, but
one of the interesting things is that the NDS’ ARM9 core has special
multiplication instructions. In particular, there is the
SMULWx instruction, which does a word*halfword
multiplication, where the halfword can be either the top or bottom
halfword of operand 2.The main result is 32×16→48 bits
long, of which only the top 32 bits are put in the destination
register. Effectively it’s like a*b>>16 without
overflow problems. As a bonus, it’s also slightly faster than the
standard MUL. By slightly changing the parameters,
the down-shift factors r and s can be made 16, fitting
perfectly with this instruction, although the internal accuracy is
made slightly worse. Additionally, careful placement of each
instruction can avoid the interlock cycle that happens for
multiplications.

The alternate isin_S3a() becomes:

Technically it’s only two instruction less, but is quite a bit
faster due to the difference in speed between MUL
and SMULWx.

2.1 High-precision, fifth order

The third order approximation actually still has a substantial error,
so it may be useful to use an additional term. This would be
the fifth-order approximation, S₅. It and its
derivative are given in Eq 14.

(14)	title="\begin{eqnarray} S_5(x) &=& ax - b x^3 + c x^5 \\ \\ \\ S_5'(x) &=& a - 3b x^2 + 5c x^4 \end{eqnarray}" alt="\begin{eqnarray} S_5(x) &=& ax - b x^3 + c x^5 \\ \\ \\ S_5'(x) &=& a - 3b x^2 + 5c x^4 \end{eqnarray}" />

To find the terms, I will again use z instead of x.
The conditions of note are the position and derivative at z = 1
and the derivative at 0. With these conditions the approximation
should behave amicably at both edges.

(15)

title="\begin{eqnarray} S_5(z=1) &=& 1 &=& a &-& b &+& c \\ \\ \\ S'_5(z=1) &=& 0 &=& a &-& 3b &+& 5c \\ \\ \\ S'_5(z=0) &=& \frac\pi2 &=& a \end{eqnarray}" alt="\begin{eqnarray} S_5(z=1) &=& 1 &=& a &-& b &+& c \\ \\ \\ S'_5(z=1) &=& 0 &=& a &-& 3b &+& 5c \\ \\ \\ S'_5(z=0) &=& \frac\pi2 &=& a \end{eqnarray}" />

Notice that these equations are linear with respect to a,
b and c, which means that it can be solved via matrices.
Technically this system of equations forms a 3×3 matrix, but since
a is already immediately known it can be reduced to a
2×2 system. I’ll spare you the details, but it leads to the
coefficients of Eq 16. Note the complete absence of
any horrid π⁵ terms that would have appeared if you had
decided not to use dimensionless terms.

(16)	title="\begin{eqnarray} a &=& \pi/2 \\ \\ b &=& \pi - 5/2 \\ \\ c &=& \pi/2 - 3/2 \end{eqnarray}" alt="\begin{eqnarray} a &=& \pi/2 \\ \\ b &=& \pi - 5/2 \\ \\ c &=& \pi/2 - 3/2 \end{eqnarray}" />

(17)	title="S_5(z) = \frac12 z (\pi - z^2 [ (2\pi-5) - z^2 (\pi - 3) ] )" alt="S_5(z) = \frac12 z (\pi - z^2 [ (2\pi-5) - z^2 (\pi - 3) ] )" />

Eq 17 is the final quintic approximation in the
form that’s most accurate and easiest to implement. The implementation
is basically an extension of the S₃ function
and left as an exercise for the reader.

2.2 High precision, fourth order

Fig 3.

Lastly, a fourth-order approximation. Normally, I wouldn’t even consider
this for a sine (odd function == odd power series and all that), but
since the devmaster post uses them and they even seem to work, there
seems to be something to them after all.

The reason those approximations work is simple: they don’t actually
approximate a sine at all; they approximate a cosine. And,
because of all the symmetries and parallels with sines and cosines,
one can be used to implement the other.

(18)	title="\begin{eqnarray} sin(x) &=& cos(x - \pi/2) \\ \\ sin(z) &=& cos(z - 1) \end{eqnarray}" alt="\begin{eqnarray} sin(x) &=& cos(x - \pi/2) \\ \\ sin(z) &=& cos(z - 1) \end{eqnarray}" />

Eq 18 is
the transformation you need to perform to turn a cosine into a sine
wave. This can be easily done in at the start of an algorithm.
What’s left is to derive a cosine approximation. Because a cosine
is even, only even powers will be needed. The base form and its
derivative are given in Eq 19.

(19)	title="\begin{eqnarray} C_4 (x) &=& a - b x^2 + c x^4 \\ \\ \\ C_4'(x) &=& - 2b x + 4c x^3 \end{eqnarray}" alt="\begin{eqnarray} C_4 (x) &=& a - b x^2 + c x^4 \\ \\ \\ C_4'(x) &=& - 2b x + 4c x^3 \end{eqnarray}" />

For the conditions, we once again look at z = 0 and z = 1,
which comes down to the eqt of equations in Eq 20.
One of the interesting thing about even functions is that the
derivative at 0 is zero, so that’s a freebie. A very important
freebie, as it means that one of the required symmetries happens
automatically.

(20)

title="\begin{eqnarray} C_4(z=0) &=& 1 &=& a \\ \\ \\ C_4(z=1) &=& 0 &=& a &-& b &+& c \\ \\ \\ C'_4(z=1) &=& -\frac\pi2 &=& &-& 2b &+& 4c \end{eqnarray}" alt="\begin{eqnarray} C_4(z=0) &=& 1 &=& a \\ \\ \\ C_4(z=1) &=& 0 &=& a &-& b &+& c \\ \\ \\ C'_4(z=1) &=& -\frac\pi2 &=& &-& 2b &+& 4c \end{eqnarray}" />

The resulting set of coefficients are listed in Eq 21.
Note that b = c+1, which may be of use later. The final
equation for the fourth order cosine approximation is
Eq 22. Only three MULs and two SUBs; nice.

(21)	title="\begin{eqnarray} a &=& 1 \\ \\ b &=& 2 - \pi/4 \\ \\ c &=& 1 - \pi/4 \end{eqnarray}" alt="\begin{eqnarray} a &=& 1 \\ \\ b &=& 2 - \pi/4 \\ \\ c &=& 1 - \pi/4 \end{eqnarray}" />

(22)	title="C_4(z) = 1 - z^2 [ (2-\pi/4) - z^2 (1-\pi/4) ]" alt="C_4(z) = 1 - z^2 [ (2-\pi/4) - z^2 (1-\pi/4) ]" />

Implementation

The floating-point implementation of Eq 22 is
again too easy to mention here, so I’ll focus on fixed-point
variations. Like with S₃, you can mix and match
fixed-point positions until you get something you like. In this
case I’ll stick to Q14 for almost everything to keep things simple.

The real trick here is to find out what you need to do about all the
other quadrants. Cutting down to four quadrants is, again, easy.
For the rest, remember that the cosine approximation calculates the top
quadrants and you need to flip the sign for the bottom quadrants.
If you think in terms of the parameter that a sine gets, you see that
only for odd semi-circles the sign needs to change. Tracing this
can be done with a single bitwise AND or a clever shift.

And an ARM9 assembly version too. As it happens, it’s only two
instuctions longer than isin_S3a9().

3 Testing

Deriving approximations is nice and all, but there’s really no point
unless you do some sort of test to see how well they perform. I’ll
look at two things: accuracy and some speed-tests. For the speed-test,
I’ll only consider the functions given here along with some traditional
ones. The accuracy test is done only for the first quadrant and in
floating-point, but the results should carry over well to a fixed-point
case. Finally, I’ll show how you can optimize the functions for accuracy.

3.1 Third and fourth-order speed

For the speed test I calculated the sine at 256 points for
x ∈ [0, 2π). There will be some loop-overhead
in the numbers, but it should be small. Tests were performed on the
NDS.

Functions under investigation are the three S₃ and
two S₄ functions given earlier. I’ve also tested
the standard floating-point sin() library function,
the libnds sinLerp() and my own isin()
function that you can find in
arctan:sine.
The cumulative and average times can be found in
Table 1.

The first thing that should be clear is just why we don’t use the
floating-point sine. I mean, seriously. There is also a clear difference
between the Thumb-compiled and ARM assembly versions, the latter being
significantly faster.

Within the compiled versions, I find it interesting to see that the
algorithmic calculations are actually faster than the LUT+lerp-based
implementations. I guess loading all those numbers from memory
really does suck.

And then there’s the assembly versions. Wow. Compared to the
compiled version they’re twice as fast, and up to four times as fast
as the LUT-based functions.

3.2 Accuracy

Fig 4 shows all the approximations in one graph.
It only shows one quadrant because the rest can be retrieved by
symmetry. I’ve also scaled the sine and its approximations by
2¹² because that’s the scale that usual fixed-point scale
right now. And to be sure, yes, this is a different chart than
Fig 1; it’s just hard to tell because the
fourth and fifth order functions are virtually identical to the
real sine line.

Fig 4.

For the high-accuracy approximations, it’s better to look at
Fig 5, which shows the errors. Here you can
clearly see a difference between S_4d and
S₅, the latter is roughly 3 times better.

There’s also a large difference between the devmaster fourth-order
sine and my own. The reason behind this is a difference in conditions.
In my case, I’ve fixed the derivatives at both end-points, which
always results in an over- or underestimate. The devmaster’s
S_4d let go of those conditions and minimized the
error. I’ll also do this in the next sub-section.

Fig 5.

Table 2 and Table 3
list some interesting statistics about
the various approximations, namely the minimum, average and maximum
errors. It also contains a Root Mean Square Deviation (RMSD), which is a
special kind of distance. If you consider the data-points as a
vector, the RMSD is the average Pythagorean length for each point.
Table 2 is normed to 2¹², whereas
Table 3 is table for the traditional floating-point
sine scale.

The RMSD values are probably the most useful to look at. From them
you can see that there is a huge gap between the low-accuracy and
high-accuracy functions of about a factor 60. And if you do your
math right, all it costs is one multiplication and one addition,
and maybe some extra shifts in the fixed-point case. That’s quite
a bargain. Compared to that, the difference between the odd and
even functions is somewhat meager: only a factor three or so.
Still, it is something.

If you look at the fixed-point table, you can see that the error
you make with S_4d and
S₅ is in the single digits. This means
that this is probably accurate enough for practical purposes.
Combined with the fact that even fifth order polynomials can be
made pretty fast, this makes them worth considering over LUTs.

3.3 Optimizing higher-order approximations

From the charts, you can see that S₄ and
S₅ all err on the same side of the sine line. You
can increase the accuracy of the approximation by tweaking the
coefficients in such a way that the errors are redistributed in
a preferable way. Two methods are possible here: shoot for a zero
error average, or minimize the RMSD. Technically minimizing the
RMSD is standard (it comes down to least-squares optimization), but
because a zero-average allows for an analytical solution, I’ll use
that. In any case, the differences in outcomes will be small.

First, think of what an average of a function means. The average
of a set of numbers is the sum divided by the size of the set. For
functions, it’s the integral of that function divided by the
interval. When you want a zero-average for an approximation, the
integral of the function and that of the approximation should
be equal. With a polynomial approximation to a sine, we get:

(23)

title="\begin{eqnarray} \int_0^1 \sum_n a_n x^n dx &=& \int_0^1 sin(x\pi/2) dx \;\; \rightarrow \\ \\ \sum_n \frac{a_n}{n+1} &=& 2/\pi , \end{eqnarray}" alt="\begin{eqnarray} \int_0^1 \sum_n a_n x^n dx &=& \int_0^1 sin(x\pi/2) dx \;\; \rightarrow \\ \\ \sum_n \frac{a_n}{n+1} &=& 2/\pi , \end{eqnarray}" />

with a_n reducing to the coefficients of the
polynomials we had before. This can be used as an alternate condition
to the derivative at 0. For S₄ and
S₅, you’ll end up with the following coefficients.