Benchmark: Fast Sqrt0 - MeasureThat.net

Script Preparation code:

var i;
var r;
var v = 2 ** 16;

function test1() {
    for (i = 0; i < 100000; ++i) {
        r = Math.sqrt(v);
    }
}

function test2() {
    for (i = 0; i < 100000; ++i) {
        r = Q_rsqrt(v) * v;
    }
}

//Based on the fast inverse square root function
// https://en.wikipedia.org/wiki/Fast_inverse_square_root
// Some original comments preserved for humor value
// Designed to try to mimic the original as closely as possible
function Q_rsqrt(number) {
    var i;
    var x2, y;
    const threehalfs = 1.5;

    x2 = number * 0.5;
    y = number;
    //evil floating bit level hacking
    var buf = new ArrayBuffer(4);
    (new Float32Array(buf))[0] = number;
    i = (new Uint32Array(buf))[0];
    i = (0x5f3759df - (i >> 1)); //What the fuck?
    (new Uint32Array(buf))[0] = i;
    y = (new Float32Array(buf))[0];
    y = y * (threehalfs - (x2 * y * y)); // 1st iteration
    //  y  = y * ( threehalfs - ( x2 * y * y ) );   // 2nd iteration, this can be removed

    return y;
}

​x
 
var i;var r;var v = 2 ** 16;​function test1() {    for (i = 0; i < 100000; ++i) {        r = Math.sqrt(v);    }}​function test2() {    for (i = 0; i < 100000; ++i) {        r = Q_rsqrt(v) * v;    }}​//Based on the fast inverse square root function// https://en.wikipedia.org/wiki/Fast_inverse_square_root// Some original comments preserved for humor value// Designed to try to mimic the original as closely as possiblefunction Q_rsqrt(number) {    var i;    var x2, y;    const threehalfs = 1.5;​    x2 = number * 0.5;    y = number;    //evil floating bit level hacking    var buf = new ArrayBuffer(4);    (new Float32Array(buf))[0] = number;    i = (new Uint32Array(buf))[0];    i = (0x5f3759df - (i >> 1)); //What the fuck?    (new Uint32Array(buf))[0] = i;    y = (new Float32Array(buf))[0];    y = y * (threehalfs - (x2 * y * y)); // 1st iteration    //  y  = y * ( threehalfs - ( x2 * y * y ) );   // 2nd iteration, this can be removed​    return y;}

Tests:

Math.sqrt
test1();
test1();
Quakes fast inverse sqrt.
test2();
test2();

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
Math.sqrt
Quakes fast inverse sqrt.

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) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.67 Safari/537.36

Browser/OS: Chrome 101 on Windows

View result in a separate tab

Test name	Executions per second
Math.sqrt	28.5 Ops/sec
Quakes fast inverse sqrt.	6.2 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):

Let's dive into the world of JavaScript microbenchmarks.

Benchmark Definition JSON

The provided Benchmark Definition JSON represents a comparison between two functions: Math.sqrt and a custom implementation of the fast inverse square root function (Q_rsqrt). The Fast Sqrt0 benchmark is designed to measure the performance difference between these two approaches.

What is being tested?

The test cases are comparing the execution speed of:

Math.sqrt: A built-in JavaScript function that calculates the square root of a given number.
Q_rsqrt: A custom implementation of the fast inverse square root function, which is based on an optimized algorithm from Wikipedia.

Options being compared

The two options being compared are:

Math.sqrt: The built-in JavaScript function.
Q_rsqrt: The custom implementation of the fast inverse square root function.

Pros and Cons

Here's a brief summary of the pros and cons of each approach:

Math.sqrt:
- Pros: Easy to use, well-documented, and widely supported.
- Cons: May be slower than optimized implementations like Q_rsqrt.
Q_rsqrt:
- Pros: Optimized for performance, can be faster than built-in functions.
- Cons: Requires manual implementation of the fast inverse square root algorithm, which can be complex.

Library and purpose

The Q_rsqrt function uses a library-like approach by:

Creating a new ArrayBuffer to store the input value.
Converting the input value to an integer using new Uint32Array(buf)[0].
Applying the optimized algorithm to calculate the square root.

This implementation is similar to how the fast inverse square root function works, but with a JavaScript twist.

Special JS feature or syntax

No special features or syntax are used in this benchmark.

Other alternatives

If you were to implement your own Q_rsqrt function without using an array buffer-like approach, you could use:

SIMD (Single Instruction, Multiple Data) instructions: Some modern CPUs support SIMD instructions that can perform operations on multiple values simultaneously.
Approximate calculations: You could use approximate methods like Newton's method or binary search to estimate the square root.

However, these alternatives might not be as efficient as using an optimized library-like approach or a built-in function like Math.sqrt.

Keep in mind that this benchmark is designed to compare the performance of two specific functions, and the results may vary depending on your specific use case and JavaScript environment.

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

**Benchmark Definition JSON**

The provided Benchmark Definition JSON represents a comparison between two functions: `Math.sqrt` and a custom implementation of the fast inverse square root function (`Q_rsqrt`). The `Fast Sqrt0` benchmark is designed to measure the performance difference between these two approaches.

**What is being tested?**

The test cases are comparing the execution speed of:

1. **`Math.sqrt`**: A built-in JavaScript function that calculates the square root of a given number.
2. **`Q_rsqrt`**: A custom implementation of the fast inverse square root function, which is based on an optimized algorithm from Wikipedia.

**Options being compared**

The two options being compared are:

1. `Math.sqrt`: The built-in JavaScript function.
2. `Q_rsqrt`: The custom implementation of the fast inverse square root function.

**Pros and Cons**

Here's a brief summary of the pros and cons of each approach:

* **`Math.sqrt`**:
	+ Pros: Easy to use, well-documented, and widely supported.
	+ Cons: May be slower than optimized implementations like `Q_rsqrt`.
* **`Q_rsqrt`**:
	+ Pros: Optimized for performance, can be faster than built-in functions.
	+ Cons: Requires manual implementation of the fast inverse square root algorithm, which can be complex.

**Library and purpose**

The `Q_rsqrt` function uses a library-like approach by:

1. Creating a new `ArrayBuffer` to store the input value.
2. Converting the input value to an integer using `new Uint32Array(buf)[0]`.
3. Applying the optimized algorithm to calculate the square root.

This implementation is similar to how the fast inverse square root function works, but with a JavaScript twist.

**Special JS feature or syntax**

No special features or syntax are used in this benchmark.

**Other alternatives**

If you were to implement your own `Q_rsqrt` function without using an array buffer-like approach, you could use:

1. SIMD (Single Instruction, Multiple Data) instructions: Some modern CPUs support SIMD instructions that can perform operations on multiple values simultaneously.
2. Approximate calculations: You could use approximate methods like Newton's method or binary search to estimate the square root.

However, these alternatives might not be as efficient as using an optimized library-like approach or a built-in function like `Math.sqrt`.

Keep in mind that this benchmark is designed to compare the performance of two specific functions, and the results may vary depending on your specific use case and JavaScript environment.

Related benchmarks:

Fast Sqrt0 (version: 0)

Compare Quakes fast inverse squareroot

Comparing performance of: Math.sqrt vs Quakes fast inverse sqrt.

Created: 2 years ago by: Guest

Jump to the latest result

Math.sqrt

Quakes fast inverse sqrt.

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):