# Defining the sine function as an oscillator

When I do something trigonometric, I reach for a library implementing common trig functions, e.g. `Math.sin`. From school through university through work, I’ve been taught to treat these functions as black boxes. Before we had calculators at school, there were books of sine tables - more black boxes. How do these functions actually work? How do you define `sin(x)`?

``````function sin(x) {
return /* ??? */;
}
``````

One definition of sine which I was familiar with is: sine is the function traced out by a point on a rotating circle, when viewing the circle from the edge. If you try to implementing sine with this definition, you look up the definition of a circle, plug in the angles, and get ...

``````function sin(x) {
return Math.sin(x);
}
``````

... great. But a different definition of sine is: sine is the function traced out by an object on a spring. A spring exerts a force on the object, pushing it back towards the equilibrium. An ideal spring is a “simple harmonic oscillator”, which means that it exerts a force proportional to the distance from the equilibrium.

Based on this definition, we can write a `sin` function which works by simulating a spring:

``````var delta = 0.001;
function springSin(x) {
var velocity = delta;
var y = 0;
for (var t = 0; t < x; t += delta) {
y += velocity;
velocity -= y * (delta * delta);
}
return y;
}
``````

We can optimize this using the repeating and symmetric nature of the sine function:

``````var delta = 0.001;
function optimizedSpringSin(x) {
var sign = 1;
if (x < 0) { x = -1; sign = -sign; }  // [0, inf]
x = x % (2 * Math.PI); // [0, 2*Math.PI]
if (Math.PI < x) { x -= Math.PI; sign = -sign; } // [0, Math.PI]
if (Math.PI/2 < x) { x = Math.PI - x; } // [0, 1/2 Math.PI]
// Now x is in [0, 1/2 PI]
return springSin(x) * sign;
}
``````

Here’s a plot of the `Math.sin` function (green) next to the `optimizedSpringSin` function (black, slightly offset):

Why does the iterative `springSin` function approximate the true sine function? Because there’s a relationship between oscillation and circles/triangles. Unfortunately I don’t understand that relationship.

The actual implementation of `sin` in math libraries uses a “Taylor series approximation” of the sine function. Unfortunately I don’t understand that, either.

What can computers do? What are the limits of mathematics? And just how busy can a busy beaver be? This year, I’m writing Busy Beavers, a unique interactive book on computability theory. You and I will take a practical and modern approach to answering these questions — or at least learning why some questions are unanswerable!

It’s only \$19, and you can get 50% off if you find the discount code ... Not quite. Hackers use the console!

After months of secret toil, I and Andrew Carr released Everyday Data Science, a unique interactive online course! You’ll make the perfect glass of lemonade using Thompson sampling. You’ll lose weight with differential equations. And you might just qualify for the Olympics with a bit of statistics!

It’s \$29, but you can get 50% off if you find the discount code ... Not quite. Hackers use the console!

### More by Jim

Tagged . All content copyright James Fisher 2017. This post is not associated with my employer.