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();
}

​x
 
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]); }

 
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]); }

 
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]); }

 
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]); }

 
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]); }

 
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]); }

 
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]); }

 
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

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

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

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.

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.

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