Benchmark: Math.sqrt() vs. Binary search sqrt

Script Preparation code:

function sqrt(x) {
  if (x < 0.0)
    return NaN;
  if (x < 1.0)
    return 1.0 / sqrt(1.0 / x);
  let xhi = x;
  let xlo = 0.0;
  let guess = x / 2.0;
  let next;
  while ((guess * guess) != x) {
    if ((guess * guess) > x)
      xhi = guess;
    else xlo = guess;
    if ((next = (xhi + xlo) / 2.0) == guess)
      break;
    guess = next;
  }
  return guess;
}

Tests:

Math.sqrt()
Math.sqrt(Math.random() * 1000000);
Binary search sqrt
sqrt(Math.random() * 1000000);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Math.sqrt()
Binary search sqrt

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Mobile Safari/537.36

Browser/OS: Chrome Mobile 135 on Android

View result in a separate tab

Test name	Executions per second
Math.sqrt()	36925936.0 Ops/sec
Binary search sqrt	1889845.6 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the explanation of the benchmark.

**Benchmark Definition JSON**

The provided JSON represents a benchmark definition for two JavaScript functions: `Math.sqrt()` and a custom implementation using binary search, denoted as "Binary search sqrt".

**What is tested?**

In this benchmark, we're comparing the performance of two different ways to calculate the square root of a number. The first approach uses the built-in `Math.sqrt()` function from the JavaScript Math library, while the second approach implements a custom algorithm using binary search.

**Options compared:**

* **Built-in Math.sqrt()**: This is the default way to calculate the square root of a number in JavaScript.
* **Binary Search sqrt**: A custom implementation that uses binary search to find the square root of a given number.

**Pros and Cons of each approach:**

* **Math.sqrt():**
	+ Pros:
		- Fast and efficient
		- Widely supported by most browsers and JavaScript engines
		- Easy to implement
	+ Cons:
		- May be less accurate for very large or very small numbers due to floating-point precision issues
* **Binary Search sqrt:**
	+ Pros:
		- Can provide more accurate results, especially for very large or very small numbers
		- Reduces reliance on floating-point arithmetic
	+ Cons:
		- More complex and harder to implement than the built-in `Math.sqrt()` function
		- May be slower than the built-in function due to additional calculations

**Library usage**

The custom "Binary search sqrt" implementation uses a simple binary search algorithm, which is not a separate library. However, the concept of binary search itself is commonly used in many algorithms and data structures.

**Special JS feature or syntax**

There are no special JavaScript features or syntaxes mentioned in this benchmark.

**Other alternatives**

If you're interested in exploring alternative approaches to calculate the square root, here are some other options:

* **Approximation methods**: There are various approximation methods available for calculating the square root of a number, such as the Babylonian method, Newton's method, or the Laguerre method.
* **Parallelization**: You could also consider parallelizing the calculation using multi-threading or concurrent programming to potentially improve performance on multi-core systems.

Keep in mind that these alternatives might not provide significant benefits over the built-in `Math.sqrt()` function for most use cases, but they can be interesting exercises for exploration and learning.

Related benchmarks:

Math.sqrt() vs. Binary search sqrt (version: 0)

Comparing performance of: Math.sqrt() vs Binary search sqrt

Created: 4 years ago by: Guest

Jump to the latest result

Math.sqrt()

Binary search sqrt

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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