Benchmark: trigata - MeasureThat.net

Script Preparation code:

function rand(min, max) {
    return Math.floor(Math.random() * (max - min + 1)) + min;
}

function angle(x, y) {
  let result = Math.atan(y / x);
  if (x < 0) {
    result += Math.PI;
  } else if (y < 0) {
    result += 2 * Math.PI;
  }
  return result;
}

function angle2(x, y) {
    if (x == 0)
      return (y == 0) ? 0 : (y > 0 ? Math.PI/2 : -Math.PI/2)
  
    var atan_xy = Math.atan(y / x)
    if (x > 0)
      return atan_xy
    else // x < 0
      return atan_xy + (y < 0 ? -Math.PI : Math.PI)
}

function myAtan2(a, b)
{
    var atan2val;
    if (b > 0) {
        atan2val = Math.atan(a/b);
    }
    else if ((b < 0) && (a >= 0)) {
        atan2val = Math.atan(a/b) + Math.PI;
    }
    else if ((b < 0) && (a < 0)) {
        atan2val = Math.atan(a/b) - Math.PI;
    }
    else if ((b = 0) && (a > 0)) {
        atan2val = Math.PI / 2;
    }
    else if ((b = 0) && (a < 0)) {
        atan2val = 0 - (Math.PI / 2 );
    }
    else if ((b = 0) && (a = 0)) {
        atan2val = 1000;
    }
  
    return atan2val;
}

function matan2(y, x){
  const c1 = Math.PI / 4;
  const c2 = Math.PI * 3 / 4;

  if (y == 0 && x == 0){
    return 0;
  }

  const abs_y = Math.abs(y);
  let angle;
  if (x >= 0){
    angle = c1 - c1 * ((x - abs_y) / (x + abs_y));
  } else {
    angle = c2 - c1 * ((x + abs_y) / (abs_y - x));
  }

  if (y < 0){
    return -angle;
  }

  return angle;
}

Tests:

native
var xO = rand(1, 1000); var yO = rand(1, 1000); Math.atan(yO, xO);
alt
var xT = rand(1, 1000); var yT = rand(1, 1000); angle(xT, yT);
alt2
var xD = rand(1, 1000); var yD = rand(1, 1000); angle2(xD, yD);
alt3
var xC = rand(1, 1000); var yC = rand(1, 1000); myAtan2(xC, yC);
alt4
var xZ = rand(1, 1000); var yZ = rand(1, 1000); matan2(xZ, yZ);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
native
alt
alt2
alt3
alt4

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

I'd be happy to explain what's being tested in this benchmark.

The provided JSON represents a JavaScript microbenchmark that compares the performance of different implementations of the `Math.atan2` function, which calculates the arctangent of two numbers (x and y) with respect to the x-axis.

Here are the options being compared:

1. **Native**: This is the built-in implementation of `Math.atan2` provided by JavaScript engines like V8 (used in Chrome).
2. **angle**: This is a custom implementation of `Math.atan2` defined in the benchmark script.
3. **angle2**: Another custom implementation of `Math.atan2` defined in the benchmark script, which seems to be similar to `angle`, but with some differences in handling edge cases.
4. **myAtan2**: A custom implementation of `Math.atan2` defined in the benchmark script, which appears to have its own logic for handling different edge cases compared to the native implementation and the other two custom implementations.

Now, let's discuss the pros and cons of each approach:

* **Native**: This is the performance-critical implementation provided by JavaScript engines. Its pros include:
	+ Optimized for performance
	+ Implemented in assembly code or highly optimized C++ code
	+ Has been thoroughly tested and benchmarked by browser vendors
	Cons include:
	+ May not be as easy to understand or debug due to its low-level nature
	+ May have limitations or quirks that are difficult to identify or fix
* **angle**: This implementation is a custom attempt to optimize `Math.atan2` for performance. Its pros include:
	+ Can potentially outperform the native implementation due to hand-optimized code
	+ May be easier to understand and debug than the native implementation
Cons include:
	+ Has not been thoroughly tested or benchmarked by browser vendors
	+ May have performance regressions or bugs that are difficult to identify
* **angle2** and **myAtan2**: These implementations also attempt to optimize `Math.atan2` for performance. Their pros include:
	+ Can potentially outperform the native implementation due to hand-optimized code
Cons include:
	+ Have not been thoroughly tested or benchmarked by browser vendors
	+ May have performance regressions or bugs that are difficult to identify

The latest benchmark results show that:

* **Native** is generally the fastest implementation, with execution rates ranging from 330,886 to 464,798 executions per second.
* **alt4** (matan2) has significantly slower execution rates compared to the other implementations.

Overall, this benchmark highlights the importance of ensuring that JavaScript engine optimizations are correct and performant. The custom implementations attempt to optimize `Math.atan2` for performance, but may not have achieved the same level of optimization as the native implementation.

Related benchmarks:

trigata (version: 0)

Comparing performance of: native vs alt vs alt2 vs alt3 vs alt4

Created: 7 years ago by: Guest

Jump to the latest result

native

alt

alt2

alt3

alt4

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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