Benchmark: fast sin cos vs math sin cos

Script Preparation code:

var random = new Float64Array(1000);
var lSin = new Float64Array(1000);
var lCos = new Float64Array(1000);
for (let i = 0; i < 1000; i++) {
    random[i] = Math.random() * 1000000;
}
for (let i = 0; i < 1000; i++) {
  lSin[i] = Math.sin(i * Math.PI / 1000);
  lCos[i] = Math.sin(i * Math.PI / 1000);
}

function fastCos(x) {
    x += 1.57079632;
    x -= ((x > 3.14159265) ? 6.28318530 : 0);
    return (x < 0) ? (1.27323954 * x) + (0.40528473 * x * x) : (1.27323954 * x) - (0.40528473 * x * x);
}

function fastSin(x) {
    x -= ((x > 3.14159265) ? 6.28318530 : 0);
    return (x < 0) ? (1.27323954 * x) + (0.40528473 * x * x) : (1.27323954 * x) - (0.40528473 * x * x);
}

function lookupSin(x) {
  return lSin[Math.round((x % 1000) * 1000) / 1000];
}

function lookupCos(x) {
  return lSin[Math.round((x % 1000) * 1000) / 1000];
}

Tests:

Math.sin
for (let i = 0; i < 1000; i++) { Math.sin(random[i]); }
Math.cos
for (let i = 0; i < 1000; i++) { Math.cos(random[i]); }
fastSin
for (let i = 0; i < 1000; i++) { fastSin(random[i]); }
fastCos
for (let i = 0; i < 1000; i++) { fastCos(random[i]); }
lookupSin
for (let i = 0; i < 1000; i++) { lookupSin(random[i]); }
lookupCos
for (let i = 0; i < 1000; i++) { lookupCos(random[i]); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Math.sin
Math.cos
fastSin
fastCos
lookupSin
lookupCos

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 26 days ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36

Browser/OS: Chrome 134 on Windows

View result in a separate tab

Test name	Executions per second
Math.sin	773096.2 Ops/sec
Math.cos	776404.9 Ops/sec
fastSin	631497.8 Ops/sec
fastCos	569495.2 Ops/sec
lookupSin	22433.9 Ops/sec
lookupCos	22587.8 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):

LLMs can make mistakes. Check important info.

I'll do my best to explain the provided benchmark and its various components.

**Overview**

The test measures the performance of different JavaScript functions for calculating sine and cosine values. The benchmark script generates random numbers between 0 and 1 million, which are then used as input to the four functions: `Math.sin`, `fastSin`, `Math.cos`, and `fastCos`.

**Functionality**

Let's break down each function:

*   **`Math.sin`**: This is a built-in JavaScript function that calculates the sine of an angle in radians.
*   **`fastSin`**: This function uses a piecewise implementation to reduce precision. It adds 1.57079632 (π) and then subtracts multiples of 6.2831853 (2\*π) to shift the range to -1 to 1, allowing it to use integer arithmetic to compute the sine.
*   **`Math.cos`**: This is another built-in JavaScript function that calculates the cosine of an angle in radians.
*   **`fastCos`**: Similar to `fastSin`, this function uses a piecewise implementation with precision reduction. It adds 1.57079632 (π) and then subtracts multiples of 6.2831853 (2\*π) to shift the range to -1 to 1.
*   **`lookupSin`** and **`lookupCos`**: These functions use arrays (`lSin` and `lCos`) populated with pre-calculated sine and cosine values at specific points. They then use these precomputed values to look up the desired value.

**Approaches**

There are three main approaches compared in this benchmark:

1.  **Native Function (Math.sin/ cos)**: These functions rely on JavaScript's built-in implementation, which is optimized for performance.
2.  **Fast Function (fastSin/fastCos)**: These functions use precision reduction techniques to speed up the calculation by reducing the number of decimal places used.
3.  **Lookup Table Approach (lookupSin/lookupCos)**: This approach uses precomputed values stored in arrays to look up the desired value, which can be faster if the input range is well-covered.

**Pros and Cons**

Here's a brief overview of each approach:

*   Native Function (Math.sin/cos):
    *   Pros:
        *   Built-in implementation, highly optimized.
        *   Typically accurate.
    *   Cons:
        *   May not be as fast due to overhead in JavaScript engine.
*   Fast Function (fastSin/fastCos):
    *   Pros:
        *   Can be faster than native functions due to precision reduction.
        *   Still provides good accuracy.
    *   Cons:
        *   Requires careful implementation to maintain accuracy.
        *   May not perform well for inputs outside the reduced range.
*   Lookup Table Approach (lookupSin/lookupCos):
    *   Pros:
        *   Can be very fast if input range is well-covered.
        *   Reduces calculation time.
    *   Cons:
        *   Requires large amounts of memory to store precomputed values.
        *   May not perform well for inputs outside the precomputed range.

**Benchmark Results**

The benchmark results show that:

*   `fastSin` and `fastCos` are faster than native functions (`Math.sin` and `Math.cos`) in this specific test case.
*   The lookup table approach (`lookupSin` and `lookupCos`) is not as fast due to the memory requirements, but it can still be a good option if the input range is well-covered.

In summary, this benchmark compares three different approaches for calculating sine and cosine values: native functions (built-in implementation), fast functions with precision reduction, and lookup table approach with precomputed values. The results highlight the importance of choosing the right approach based on specific requirements and constraints.

Related benchmarks:

fast sin cos vs math sin cos (version: 0)

testing faster functions

Comparing performance of: Math.sin vs Math.cos vs fastSin vs fastCos vs lookupSin vs lookupCos

Created: one year ago by: Guest

Jump to the latest result

Math.sin

Math.cos

fastSin

fastCos

lookupSin

lookupCos

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):