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

Autogenerated LLM Summary (model llama3.2:3b, generated 26 days 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.

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 114 on Windows

View result in a separate tab

Test name	Executions per second
Math.sin	3187.6 Ops/sec
Math.cos	3449.3 Ops/sec
fastSin	4900.3 Ops/sec
fastCos	4490.5 Ops/sec
lookupSin	1243.4 Ops/sec
lookupCos	1293.5 Ops/sec

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 26 days ago):