How to actually do sin(x) quickly in C++

On Friday, April 18th, hackernews user ashvardanian posted Less slow C++. The post has over 183 (up)votes, however kllrnohj brought up a terrific point regarding if these are actual optimizations or simply wrong approximations.

Lets look at the desmos graph for sin(x) against ashvardanian’s formula (a Taylor series of degree 5). In red, sin(x), in blue, the approximation.

Yeah, that is not going to work.

Fortunately for everyone, I have a solution. From my own genius (as Perplexity can’t do zig code, or any AI for that matter), we can now make the original code more accurate. The input will contain the angle in radians, and the degree of accuracy we want. The code is in Zig as I need to learn Zig, I do not want to write C++, and zig does cross-compilation anyway.

Let’s take a look:

const std = @import("std");
const builtin = @import("builtin");

fn factorial(n: usize) f64 {
    var result: f64 = 1.0;
    for (1..n + 1) |i| {
        result *= @floatFromInt(i);
    }
    return result;
}

pub export fn f64_sin_maclaurin_dynamic(x: f64, degree: usize) f64 {
    // Degree must be odd and >= 1; if even, reduce by 1
    const max_degree = if (degree % 2 == 0) degree - 1 else degree;
    var sum: f64 = 0.0;

    // x^(2n+1), start with n=0 -> x^1
    var power: f64 = x;
    var sign: f64 = 1.0;
    var n: usize = 0;
    while ((2 * n + 1) <= max_degree) : (n += 1) {
        const denominator = factorial(2 * n + 1);
        sum += sign * power / denominator;

        // Prep for next term
        power *= x * x;
        sign = -sign;
    }

    return sum;
}

This is a Maclaurin expansion of sin(x)! Everyone wins!

Now, one may ask themselves, how do I know what degree to use? After all, it is daunting to have to estimate that on the fly, and we need to know what the result should be (close to).

Fortunately, we have desmos to find the ground truth of any sin function value!. We find that (in radians):

sin(1.5) = 0.9974949866

We run our script:

const std = @import("std");
const lib = @import("root.zig");

pub fn main() !void {
    for (1..25) |i| {
        std.debug.print("Estimation with degree {d}: {d}\n", .{ i, lib.f64_sin_maclaurin_dynamic(1.5, i) });
    }
}

% zig run src/main.zig
Estimation with degree 1: 1.5
Estimation with degree 2: 1.5
Estimation with degree 3: 0.9375
Estimation with degree 4: 0.9375
Estimation with degree 5: 1.00078125
Estimation with degree 6: 1.00078125
Estimation with degree 7: 0.9973911830357143
Estimation with degree 8: 0.9973911830357143
Estimation with degree 9: 0.9974971226283482
Estimation with degree 10: 0.9974971226283482
Estimation with degree 11: 0.9974949556821353
Estimation with degree 12: 0.9974949556821353
Estimation with degree 13: 0.9974949869361672
Estimation with degree 14: 0.9974949869361672
Estimation with degree 15: 0.9974949866013026
Estimation with degree 16: 0.9974949866013026
Estimation with degree 17: 0.9974949866040727
Estimation with degree 18: 0.9974949866040727
Estimation with degree 19: 0.9974949866040544
Estimation with degree 20: 0.9974949866040544
Estimation with degree 21: 0.9974949866040546
Estimation with degree 22: 0.9974949866040546
Estimation with degree 23: 0.9974949866040546
Estimation with degree 24: 0.9974949866040546

There we go! We just need to change the original f64_sin_maclaurin_dynamic() to use the 15th degree, and we should be good!

Written on: Apr 19, 2025