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: 4 months ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Safari/605.1.15

Browser/OS: Safari 26 on Mac OS X 10.15.7

View result in a separate tab

Math.cos

3.7M/s

fastCos

3.7M/s

fastSin

3.7M/s

Math.sin

3.7M/s

lookupSin

8K/s

lookupCos

7K/s

View exact numbers

Test name	Executions per second
✓ Math.cos	3,739,017 Ops/sec
fastCos	3,725,256 Ops/sec
fastSin	3,721,392 Ops/sec
Math.sin	3,713,717 Ops/sec
lookupSin	7,506 Ops/sec
lookupCos	7,434 Ops/sec

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

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: 3 years ago by: Guest

Go to the latest result

Math.sin

Math.cos

fastSin

fastCos

lookupSin

lookupCos

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

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: 3 years ago by: Guest

Go to the latest result

Math.sin

Math.cos

fastSin

fastCos

lookupSin

lookupCos

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

Related benchmarks

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