Benchmark: normalize vector - Math.sqrt vs all squared vs all squared 1

Tests:

Math.sqrt
const x = 1; const y = -1; const velocity = { x: 0, y: 0 }; const length = Math.sqrt(x * x + y * y); velocity.x = length > 0 ? x / length : 0; velocity.y = length > 0 ? y / length : 0;
all squared
const x = 1; const y = -1; const velocity = { x: 0, y: 0 }; const lengthSquared = x ** 2 + y ** 2; velocity.x = (lengthSquared > 0 ? x ** 2 / lengthSquared : 0) * (x < 0 ? -1 : 1); velocity.y = (lengthSquared > 0 ? y ** 2 / lengthSquared : 0) * (y < 0 ? -1 : 1);
all squared 1
const x = 1; const y = -1; const velocity = { x: 0, y: 0 }; const lengthSquared = x ** 2 + y ** 2; const velocityScale = lengthSquared > 0 ? 1 / lengthSquared : 0; velocity.x = x * velocityScale; velocity.y = y * velocityScale;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Math.sqrt
all squared
all squared 1

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 years ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:122.0) Gecko/20100101 Firefox/122.0

Browser/OS: Firefox 122 on Windows

View result in a separate tab

Test name	Executions per second
Math.sqrt	149074000.0 Ops/sec
all squared	332072096.0 Ops/sec
all squared 1	325019264.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and its test cases.

**Benchmark Overview**

The benchmark is designed to compare three approaches for normalizing vectors in JavaScript:

1. `Math.sqrt`: using the `Math.sqrt` function to calculate the length of the vector, followed by scaling the vector components.
2. `all squared`: directly calculating the square of each component of the vector and dividing it by the sum of squares of both components (length).
3. `all squared 1`: similar to the second approach, but multiplying each component with the inverse of its squared value.

**Options Compared**

The three options are compared in terms of their execution speed, which is measured in executions per second.

**Pros and Cons of Each Approach**

1. **Math.sqrt**: This approach uses a well-known mathematical function that has been optimized for performance.
	* Pros: generally faster than the other two approaches due to its optimized implementation.
	* Cons: may involve additional function calls or memory allocations, depending on the specific JavaScript engine used.
2. **all squared**: This approach involves direct calculations of squares and divisions, which can be slower due to the overhead of arithmetic operations.
	* Pros: avoids potential overhead of function calls and simplifies the code.
	* Cons: may be slower than the `Math.sqrt` approach due to the complexity of the calculation.
3. **all squared 1**: This approach is similar to the second one but includes additional logic for handling negative component values, which can introduce extra complexity and slow it down.

**Library and Special JS Features**

There are no explicit libraries used in this benchmark, as all calculations are performed using built-in JavaScript functions (e.g., `Math.sqrt`, exponentiation).

However, there is a special JavaScript feature at play: **arithmetic operations on numbers with the same precision as floating-point types**. In modern JavaScript engines, when performing arithmetic operations on integers or floats, the results may be represented in a different format due to numerical stability considerations (e.g., avoiding integer overflow). This behavior can affect performance and accuracy of calculations.

**Other Alternatives**

To further optimize vector normalization, other approaches could include:

1. **Native assembly code**: using low-level assembly languages like x86 or ARM instruction sets for optimal execution speed.
2. **Just-In-Time (JIT) compilation**: compiling the benchmark script into machine-specific bytecode at runtime to minimize overhead and improve performance.
3. **Parallelization**: executing multiple instances of each approach concurrently to take advantage of multi-core processors and parallel processing capabilities.

Keep in mind that these alternatives would likely require significant changes to the benchmark codebase and may not be feasible for a simple benchmark like this one.

Related benchmarks:

normalize vector - Math.sqrt vs all squared vs all squared 1 (version: 0)

Comparing performance of: Math.sqrt vs all squared vs all squared 1

Created: 2 years ago by: Guest

Jump to the latest result

Math.sqrt

all squared

all squared 1

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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