Benchmark: Trig functions - MeasureThat.net

Script Preparation code:

var N = 1000000;
var x = new Float32Array(N);
var y = new Float32Array(N);
var theta = new Float32Array(N);

for (var i = 0; i < N; ++i) {
	x[i] = 100* Math.random();
	y[i] = 100* Math.random();
}
for (var i = 0; i < N; ++i) {
	theta[i] = 2 * Math.PI * Math.random();
}

Tests:

sin
var fn = Math.sin; for (var i = 0; i < N; ++i) { fn(theta[i]); }
cos
var fn = Math.cos; for (var i = 0; i < N; ++i) { fn(theta[i]); }
tan
var fn = Math.tan; for (var i = 0; i < N; ++i) { fn(theta[i]); }
asin
var fn = Math.asin; for (var i = 0; i < N; ++i) { fn(x[i]); }
acos
var fn = Math.acos; for (var i = 0; i < N; ++i) { fn(x[i]); }
atan
var fn = Math.atan; for (var i = 0; i < N; ++i) { fn(x[i]); }
atan2
var fn = Math.atan; for (var i = 0; i < N; ++i) { fn(x[i], y[i]); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
sin
cos
tan
asin
acos
atan
atan2

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 135 on Windows

View result in a separate tab

Test name	Executions per second
sin	286.7 Ops/sec
cos	284.6 Ops/sec
tan	286.1 Ops/sec
asin	292.0 Ops/sec
acos	291.8 Ops/sec
atan	293.3 Ops/sec
atan2	189.9 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript trigonometric functions benchmarking.

The provided JSON represents a series of individual test cases that measure the performance of different built-in JavaScript trigonometric functions: `sin`, `cos`, `tan`, `asin`, `acos`, and `atan`. The tests are designed to compare the execution speed of these functions for various input values, including angles in radians.

Here's what's being tested:

* **Math.sin**, Math.cos, and Math.tan**: These functions take a single argument representing an angle in radians. The test generates random angles between 0 and 2π (radians) and measures the time it takes to compute their sine, cosine, or tangent values using these functions.
* **Math.asin**, Math.acos, and Math.atan**: These inverse trigonometric functions take a single argument representing a value between -1 and 1. The test generates random input values for these functions and measures the time it takes to compute their results.

Now, let's explore the different approaches being compared:

* **Single-argument vs. Two-argument `atan`**: The `atan` function with one argument returns the arctangent of a single value, while the version with two arguments returns the arctangent of a pair of values (x and y coordinates). The test compares their performance for both cases.
* **Inverse trigonometric functions vs. Trigonometric functions**: This comparison is straightforward, as it measures the speed of computing inverse trigonometric functions versus regular trigonometric functions.

Pros and cons of each approach:

* Using a single array to store input values (e.g., `theta`) can reduce memory allocation overhead and improve performance.
* Reusing the same array for both computation and storage can lead to better cache locality, which might result in faster execution times.
* The test case with `atan2` is much slower due to its complexity and the need to perform additional calculations.

Other considerations:

* **Library usage**: Some tests use libraries like Math.js or MathTron, but they are not explicitly mentioned in the provided JSON. If used, these libraries might affect the results.
* **Special JavaScript features or syntax**: The test does not utilize any special JavaScript features or syntax that would require additional explanation.

Alternatives to the current benchmarking approach:

* Using a different set of input values (e.g., fractional angles) to better represent real-world scenarios.
* Incorporating additional tests for other trigonometric functions, such as `atanh` or `acosh`.
* Comparing performance with different JavaScript engines or browsers.

Keep in mind that this is just an analysis based on the provided information. A deeper understanding of the specific requirements and goals of the benchmarking project would be necessary to provide more tailored advice.

Related benchmarks:

Trig functions (version: 0)

Which of the built-in trig functions are fastest? slowest?

Comparing performance of: sin vs cos vs tan vs asin vs acos vs atan vs atan2

Created: 8 years ago by: Registered User

Jump to the latest result

sin

cos

tan

asin

acos

atan

atan2

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):