Turns are Better than Radians

Some clip ago, overmuch effort was expended to person group to switch approximations of “pi” (3.14159…) pinch approximations of “tau” (6. 28318…). The idea, according to galore blog posts and YouTube videos, was that communal formulas go simpler, and it’s easier to activity pinch a changeless describing an entire circle alternatively of half a circle.

Generally, I agree. While it’s a insignificant point, it’s worthy making. Most codification does get somewhat amended if you switch pi pinch tau.

However, successful each the fanfare, a acold much impactful opportunity was overlooked. Instead of replacing pi pinch tau, astir of the clip pi tin beryllium removed entirely.

First, see the communal lawsuit for pi and tau successful code: converting things to and from radians for calls to trigonometric functions. If you’ve ever utilized these constants, the immense mostly of what you wrote astir apt did thing for illustration this:

y = center.y + (center.y * Math::sin(h * Math_TAU) * s) - (cursor->get_height() / 2);

That’s not maine constructing an example, that’s maine randomly opening the root codification for the Godot Engine connected github and searching for “tau”. The portion of codification above, and dozens of akin uses, is what comes up.

There is thing typical present astir Godot. If you opened immoderate random crippled motor codebase, you could do the nonstop aforesaid hunt and spot the nonstop aforesaid benignant of usage.

Notice what is going connected here: the programmer has a worth h which is already periodic connected the scope 0 to 1, but they multiply by tau because they request to telephone sin.

This whitethorn look very sensible if that’s arsenic acold arsenic you look. But what astir the implementation of sin?

There are galore implementations of sin, but nary matter which 1 you look at, adjacent the introduction constituent of the usability you’ll spot thing for illustration this:

_PS256_CONST(cephes_FOPI, 1.27323954473516); ... y = _mm256_mul_ps(x, *(v8sf*)_ps256_cephes_FOPI);

Again, not maine making up an illustration - that’s from this commonly referenced AVX2 implementation of sin. It’s not different aliases weird - beautiful overmuch each accelerated trig room is going to do thing very similar.

What does this statement do? It multiplies the input by the changeless 1.27323954473516.

Which conscionable truthful happens to beryllium 4/pi.

So the calling codification is doing this:

sin(h * 2 * pi)

but the room codification instantly does this:

y = (4 / pi) * x

which intends the calling codification is multiplying by a facet of pi just truthful the room codification tin instantly disagreement it backmost retired again. It’s virtually a conversion to radians and backmost for nary reason. If some programmers had conscionable agreed not to usage radians, and alternatively utilized the original [0, 1] domain that h was already on, some their jobs get simpler: the caller saves a multiply, while the room gets a simpler-to-understand, exact constant.

And the “exact” portion is really rather interesting. Not only do you salary for an other multiply erstwhile you spuriously person to radians, but it’s besides worthy noting that each communal radian angles too 0 are difficult to represent. Want to shop 90 degrees successful radians? No matter really galore bits you use, it will ne'er beryllium exact.

90 degrees connected [0, 1], however, is conscionable 0.25 - a spot shape that doesn’t moreover require immoderate bits of mantissa astatine all! 0.5? Same! 0.75? Just one bit of mantissa to correspond exactly.

So the [0, 1] scope is not only much computationally businesslike than radians, it is besides much compact and precise erstwhile representing emblematic values that often hap successful applicable use.

I tin understand why immoderate group would beryllium worried astir making this switch. Even if you judge maine that each user-side codification multiplies by pi aliases tau, and each library-side codification divides it backmost out, you still whitethorn person that sinking “math people feeling” that you’d beryllium doing thing incorrect if you stopped utilizing radians.

But mathematics ne'er decreed that sine and cosine person to return radian arguments!

The thought of parameterizing a circle from zero to 1 alternatively of from zero to tau is not a random thought I made up for this blog post. It’s really a legitimate, existing mathematical construct, and it moreover has a name: it’s called a turn.

In turns, 0 is 0 degrees, 0.5 is 180 degrees, 1 is 360 degrees, 2 is 720 degrees, and truthful on. It’s precisely what we wanted.

So if you are worried that your mathematics coach will get huffy astatine you, location is nary origin for concern. Just show them that you considered the matter carefully, and decided that parameterizing your angles successful turns alternatively of successful radians was the astir businesslike method for the problem astatine hand!

If you wrote your ain mathematics library, aliases you copied personification else’s into your project, hopefully it is rather clear really you tin move distant from radians and destruct pi and tau from your codebase. All you person to do is return your misdeed and cos functions and make them return turns instead of radians, which usually involves thing but a speedy accommodation to a azygous constant.

If you want to support bequest code, prime a different sanction for the caller turn-based trig functions. Then, for bequest code, you tin still support the aged radian-based misdeed and cos by making those routines thunk done to the caller routines, doing the divide-by-tau on the way.

It’s very elemental - conscionable a fewer lines of codification to make the switch.

However, though I find turns to beryllium the astir convenient reparameterization, it’s not the only alternative. Especially if you don’t rotation your ain mathematics routines (and possibly moreover if you do), you whitethorn alternatively want to see utilizing half turns, wherever a afloat circle is [0, 2]. It’s a spot much confusing, but…

It turns retired (pun intended!) that if you spell looking for it, successful immoderate mathematics libraries you will already find misdeed and cos functions parameterized connected half-turns alternatively of radians. For example, the CUDA sincospi intrinsic computes the sine and cosine of the input multiplied by pi, which is simply a half-turn.

This is great. If you’re targeting a level pinch sincospi already available, you tin extremity utilizing pi and tau constants successful your codification correct now without rubbing your libraries astatine all. Just commencement calling sincospi pinch half-turns alternatively of misdeed and cos pinch radians, and you’re bully to go.

Having now managed full codebases wherever I stopped utilizing radians, I tin safely opportunity I ne'er miss them. All the superfluous tau’s and pi’s disappear, and everything sounds much clearly.

The aforesaid logic for modifying misdeed and cos applies to the remainder of the modular trig functions arsenic well, truthful you tin destruct radians everyplace if you choose. Libraries almost ever person distant from radians internally anyway, and past person backmost to radians connected the measurement out, truthful switching to turns aliases half-turns everyplace is usually conscionable a matter of deleting codification and not overmuch else.