Benchmark: Fast approx. atan2 vs Math.atan2 vs fast accurate atan2

Script Preparation code:

const ONEQTR_PI = Math.PI / 4;
const THRQTR_PI = (3 * Math.PI) / 4;

const HALF_PI = Math.PI / 2;

// https://gist.github.com/volkansalma/2972237#file-atan2_approximation-c-L29
const fastAtan2 = (y, x) => {
	const abs_y = Math.abs(y) + 1e-10; // kludge to prevent 0/0 condition
	let angle, r;
	if (x < 0) {
		r = (x + abs_y) / (abs_y - x);
		angle = THRQTR_PI;
	} else {
		r = (x - abs_y) / (x + abs_y);
		angle = ONEQTR_PI;
	}
	angle += (0.1963 * r * r - 0.9817) * r;
	return y < 0 ? -angle : angle;
};

// https://mazzo.li/posts/vectorized-atan2.html
const accurateFastAtan2 = (y, x) => {
	const swap = Math.abs(x) < Math.abs(y);
	const denominator = (swap ? y : x) === 0 ? 0.00000001 : swap ? y : x;
	const atan_input = (swap ? x : y) / denominator;

	const a1 = 0.99997726;
	const a3 = -0.33262347;
	const a5 = 0.19354346;
	const a7 = -0.11643287;
	const a9 = 0.05265332;
	const a11 = -0.0117212;

	const z_sq = atan_input * atan_input;
	let res = atan_input * (a1 + z_sq * (a3 + z_sq * (a5 + z_sq * (a7 + z_sq * (a9 + z_sq * a11)))));

	if (swap) res = Math.sign(atan_input) * HALF_PI - res;
	if (x < 0.0) res = Math.sign(y) * MATH.PI + res;

	return res;
};

Tests:

Math.atan2
eval(''); var k = [1, .23, 0.12, 929, 8172, 9.2, 21.2].map(e => Math.atan2(e, .5));
fast approx. atan2
eval(''); var k = [1, .23, 0.12, 929, 8172, 9.2, 21.2].map(e => fastAtan2(e, .5));
accurate approx atan2
eval(''); var k = [1, .23, 0.12, 929, 8172, 9.2, 21.2].map(e => accurateFastAtan2(e, .5));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Math.atan2
fast approx. atan2
accurate approx atan2

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Safari 26 on Mac OS X 10.15.7

View result in a separate tab

fast approx. atan2

33.6M/s

accurate approx atan2

20.3M/s

Math.atan2

13.6M/s

View exact numbers

Test name	Executions per second
✓ fast approx. atan2	33,551,266 Ops/sec
accurate approx atan2	20,342,814 Ops/sec
Math.atan2	13,583,317 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 9 months ago):

LLMs can make mistakes. Check important info.

This benchmark compares three different approaches to calculating the angle (in radians) from the x and y coordinates to the origin in a Cartesian coordinate system. The methods being tested are:

1. **Math.atan2**: This is a built-in JavaScript function that returns the arctangent of the quotient of its two arguments (y, x), which represents the angle relative to the positive x-axis.

2. **fastAtan2**: This is a custom implementation that approximates the behavior of Math.atan2 but is designed to be faster. It uses a series of mathematical transformations and conditions to calculate the angle based on the signs and magnitudes of x and y.

3. **accurateFastAtan2**: This method also approximates atan2 but aims for increased precision. It adopts a different approach by first determining if the input coordinates (x, y) require a swap based on their absolute values. It then performs polynomial approximation using specific coefficients to refine the output.

### Pros and Cons of Each Approach

#### 1. Math.atan2
- **Pros**:
  - Built-in and thus well-optimized for general use across all JavaScript environments.
  - Provides accurate results across all quadrants.
- **Cons**:
  - May be slower compared to the custom implementations because it likely includes additional checks and handling inside the native implementation.

#### 2. fastAtan2
- **Pros**:
  - Aims for performance, making it faster than Math.atan2 for many inputs due to a reduced number of operations.
  - Useful in performance-critical applications, such as gaming or real-time graphics, where the exact angle isn't as crucial.
- **Cons**:
  - Adequate accuracy but might fall short in edge cases or extreme values, particularly when inputs are very close to zero or far apart.

#### 3. accurateFastAtan2
- **Pros**:
  - Strikes a balance between speed and accuracy. It generally yields results that are closer to the actual arctangent values compared to fastAtan2.
  - The polynomial approximation allows for a reasonable accuracy even for values that might challenge simpler algorithms.
- **Cons**:
  - Slightly slower than fastAtan2 due to the overhead of additional mathematical operations and checks.

### Other Considerations
- The benchmark utilizes `eval('')` to create a scoped environment for the performance testing, which allows the use of the custom functions without external interference.
- The benchmarking results indicate the number of executions per second, providing a quantitative comparison of how each method performs in the tested environment.

### Alternative Approaches
- **Precision Libraries**: Libraries such as math.js or numeric.js can be used for more complex mathematical operations, offering enhanced reliability and additional features.
- **WebAssembly**: For applications where extreme performance and speed are required, one might consider implementing atan2 calculations in a language like C or Rust, compiling to WebAssembly (Wasm) for better execution speed.
- **Optimized Algorithms**: Exploring other mathematical optimizations or approximation techniques, such as Cordic algorithms, which can provide faster convergence for certain types of trigonometric calculations.

### Summary
The benchmark presents a clear comparison of three approaches to calculating atan2, highlighting the trade-off between performance and precision. Each method has its target use case, and the choice depends on the requirements of the application—whether speed or accuracy is the priority.

Fast approx. atan2 vs Math.atan2 vs fast accurate atan2 (version: 1)

Comparing performance of: `Math.atan2 vs fast approx. atan2 vs accurate approx atan2`

Created: 9 months ago by: Guest

Go to the latest result

Math.atan2

fast approx. atan2

accurate approx atan2

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 9 months ago):

Fast approx. atan2 vs Math.atan2 vs fast accurate atan2 (version: 1)

Comparing performance of: Math.atan2 vs fast approx. atan2 vs accurate approx atan2

Created: 9 months ago by: Guest

Go to the latest result

Math.atan2

fast approx. atan2

accurate approx atan2

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 9 months ago):

Related benchmarks

Comparing performance of: `Math.atan2 vs fast approx. atan2 vs accurate approx atan2`