Benchmark: sin vs fast sin - MeasureThat.net

Script Preparation code:

const PI = Math.PI;
const TAU = PI * 2;
const B = 4 / PI;
const C = -4 / TAU;
var sin = x =>  {
    return (B * x + C * x * ((x < 0) ? -x : x));
};

Tests:

Math.sin
let k = []; for (let i = 0; i < 100; ++i) k.push(Math.sin(i));
fast sin
let k = []; for (let i = 0; i < 100; ++i) k.push(sin(i));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Math.sin
fast sin

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 8 months ago)

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

Browser/OS: Chrome 139 on Windows

View result in a separate tab

Test name	Executions per second
Math.sin	437367.2 Ops/sec
fast sin	893363.9 Ops/sec

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

LLMs can make mistakes. Check important info.

Measuring the performance of JavaScript functions is an interesting topic.

The provided JSON represents two benchmark cases:

**Benchmark Definition**

The first part, `"Script Preparation Code"`, defines a custom `sin` function using a mathematical formula to approximate the sine function. The code includes constants for π (`PI`) and τ (`TAU`), which are used in the formula. This implementation aims to provide faster execution compared to the built-in `Math.sin` function.

**Benchmark Comparison**

Two test cases compare the performance of two JavaScript functions:

1. `sin(x)`: A custom, fast approximation of the sine function using the mathematical formula.
2. `Math.sin(x)`: The standard, built-in JavaScript implementation of the sine function.

These two implementations are compared to determine which one is faster and more efficient for a specific task (pushing values onto an array).

**Pros and Cons**

Here's a brief analysis of each approach:

1. **Custom sin** (`sin(x)`):
	* Pros:
		+ Faster execution due to optimized mathematical formula.
		+ May be useful in cases where a precise sine value is not required.
	* Cons:
		+ More complex code, which can make it harder to understand and maintain.
		+ May not perform as well on devices with limited computational resources.
2. **Built-in Math.sin** (`Math.sin(x)`):
	* Pros:
		+ Widely supported and well-maintained by the JavaScript community.
		+ Often optimized for performance and can take advantage of hardware acceleration.
	* Cons:
		+ May be slower than the custom implementation due to overhead from standard library calls.

**Library: None**

There are no external libraries used in this benchmark. However, if we were to extend this benchmark to compare other JavaScript functions or algorithms, we might consider using libraries like Benchmark.js or jsbench.org to simplify the process of setting up and running benchmarks.

**Special JS Features/Syntax: None**

This benchmark does not use any special JavaScript features or syntax beyond standard language constructs. However, it's worth noting that some optimizations, such as use of `const` for immutable variables or `for...of` loops, can provide performance benefits in certain cases.

**Other Alternatives**

If you're interested in exploring alternative approaches to benchmarking JavaScript functions, consider the following:

1. **Benchmark.js**: A popular library for creating benchmarks that support a wide range of browsers and environments.
2. **jsbench.org**: A web-based platform for running JavaScript benchmarks, providing an easy-to-use interface for testing performance and comparing results.
3. **V8 Benchmark Suite**: A set of benchmarking tests developed by the V8 JavaScript engine team to measure the performance of different JavaScript algorithms and implementations.

These alternatives can help you create more comprehensive and standardized benchmarks for your JavaScript projects.

Related benchmarks:

sin vs fast sin (version: 0)

Comparing performance of: Math.sin vs fast sin

Created: 4 years ago by: Guest

Jump to the latest result

Math.sin

fast sin

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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