Benchmark: Sqrt vs Alpha max plus beta min algorithm vs lookup table vs **0.5

Script Preparation code:

const hypotTable = [];
for(let i = 0; i < 10000; i++) {
  hypotTable[i] = Math.sqrt(i);
}
function hypotLookup(i) {
  return hypotTable[i];
}

AخA
 
const hypotTable = [];for(let i = 0; i < 10000; i++) {  hypotTable[i] = Math.sqrt(i);}function hypotLookup(i) {  return hypotTable[i];}

Tests:

Math.sqrt()

const RAD_PER_DEG = Math.PI / 180;
for(let i = 0; i < 360; i += 0.1) {
  const r = i * RAD_PER_DEG;
  const d = (100 / 360) * i;
  const x = Math.sin(r) * d;
  const y = Math.cos(r) * d;
  const s = Math.sqrt(x * x + y * y);
}

 
const RAD_PER_DEG = Math.PI / 180;for(let i = 0; i < 360; i += 0.1) {  const r = i * RAD_PER_DEG;  const d = (100 / 360) * i;  const x = Math.sin(r) * d;  const y = Math.cos(r) * d;  const s = Math.sqrt(x * x + y * y);}

Alpha max plus beta min

const ALPHA = 0.96043387010342;
const BETA = 0.397824734759316;
const RAD_PER_DEG = Math.PI / 180;
for(let i = 0; i < 360; i += 0.1) {
  const r = i * RAD_PER_DEG;
  const d = (100 / 360) * i;
  const x = Math.abs(Math.sin(r) * d);
  const y = Math.abs(Math.cos(r) * d);
  const h = x > y ? ALPHA*x + BETA*y : ALPHA*y + BETA*x;
}

 
const ALPHA = 0.96043387010342;const BETA = 0.397824734759316;const RAD_PER_DEG = Math.PI / 180;for(let i = 0; i < 360; i += 0.1) {  const r = i * RAD_PER_DEG;  const d = (100 / 360) * i;  const x = Math.abs(Math.sin(r) * d);  const y = Math.abs(Math.cos(r) * d);  const h = x > y ? ALPHA*x + BETA*y : ALPHA*y + BETA*x;}

Lookup table

const RAD_PER_DEG = Math.PI / 180;
for(let i = 0; i < 360; i += 0.1) {
  const r = i * RAD_PER_DEG;
  const d = (100 / 360) * i;
  const x = Math.sin(r) * d;
  const y = Math.cos(r) * d;
  const h = hypotLookup(Math.floor(x * x + y * y));
}

 
const RAD_PER_DEG = Math.PI / 180;for(let i = 0; i < 360; i += 0.1) {  const r = i * RAD_PER_DEG;  const d = (100 / 360) * i;  const x = Math.sin(r) * d;  const y = Math.cos(r) * d;  const h = hypotLookup(Math.floor(x * x + y * y));}

** 0.5

const RAD_PER_DEG = Math.PI / 180;
for(let i = 0; i < 360; i += 0.1) {
  const r = i * RAD_PER_DEG;
  const d = (100 / 360) * i;
  const x = Math.sin(r) * d;
  const y = Math.cos(r) * d;
  const s = (x * x + y * y) ** 0.5;
}

 
const RAD_PER_DEG = Math.PI / 180;for(let i = 0; i < 360; i += 0.1) {  const r = i * RAD_PER_DEG;  const d = (100 / 360) * i;  const x = Math.sin(r) * d;  const y = Math.cos(r) * d;  const s = (x * x + y * y) ** 0.5;}

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()
Alpha max plus beta min
Lookup table
** 0.5

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Safari 15 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Math.sqrt()	1670.4 Ops/sec
Alpha max plus beta min	1252.1 Ops/sec
Lookup table	1356.0 Ops/sec
** 0.5	2372.7 Ops/sec

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

Let's dive into the benchmark!

Benchmark Overview

The provided JSON represents a JavaScript microbenchmarking test case. The goal of this test is to compare the performance of different approaches for calculating the square root of a number, specifically in the context of trigonometric calculations.

Benchmarked Approaches

There are four approaches being compared:

Math.sqrt(): This is the built-in sqrt() method of the JavaScript Math object.
Alpha max plus beta min algorithm: This is an optimization technique that uses two constants, Alpha and Beta, to calculate the square root of a sum of squares. The formula involves comparing the absolute values of sine and cosine functions, then applying a weighted average based on these values.
Lookup table: A lookup table is created in advance and used to look up pre-calculated square roots for specific input values. In this case, the hypotLookup() function accesses the lookup table.
**** 0.5**: This approach simply uses the constant value of 0.5 as a multiplier and exponent for the input number.

Pros and Cons

Here's a brief summary of each approach:

Math.sqrt(): Pros: simple, widely supported; Cons: slowest of all approaches.
Alpha max plus beta min algorithm: Pros: can be faster than Math.sqrt() for certain inputs; Cons: requires constants Alpha and Beta to be set correctly.
Lookup table: Pros: pre-calculates square roots in advance, potentially fast for repeated calculations; Cons: memory-intensive and limited scalability.
**** 0.5**: Pros: extremely simple and easy to implement; Cons: likely the slowest of all approaches.

Library Usage

In this benchmark, a custom hypotLookup() function is used with a lookup table. The purpose of this library is to provide an efficient way to look up pre-calculated square roots for specific input values, allowing for faster calculations.

Special JavaScript Features or Syntax

None are explicitly mentioned in the provided JSON. However, it's worth noting that these benchmarks rely on standard JavaScript features like functions, loops, and conditional statements.

Other Alternatives

For calculating square roots in JavaScript, other alternatives might include:

Approximate algorithms: There are several approximation algorithms available for computing square roots, such as Newton-Raphson or Babylonian method.
Specialized libraries: Libraries like mathjs or decimal.js provide optimized implementations of mathematical functions, including square root calculations.

Keep in mind that these alternatives might not be directly comparable to the approaches tested in this benchmark, and their performance may vary depending on specific use cases and requirements.

LLMs can make mistakes. Check important info.

Let's dive into the benchmark!

**Benchmark Overview**

**Benchmarked Approaches**

There are four approaches being compared:

1. **Math.sqrt()**: This is the built-in `sqrt()` method of the JavaScript Math object.
2. **Alpha max plus beta min algorithm**: This is an optimization technique that uses two constants, Alpha and Beta, to calculate the square root of a sum of squares. The formula involves comparing the absolute values of sine and cosine functions, then applying a weighted average based on these values.
3. **Lookup table**: A lookup table is created in advance and used to look up pre-calculated square roots for specific input values. In this case, the `hypotLookup()` function accesses the lookup table.
4. **** 0.5**: This approach simply uses the constant value of 0.5 as a multiplier and exponent for the input number.

**Pros and Cons**

Here's a brief summary of each approach:

1. **Math.sqrt()**: Pros: simple, widely supported; Cons: slowest of all approaches.
2. **Alpha max plus beta min algorithm**: Pros: can be faster than Math.sqrt() for certain inputs; Cons: requires constants Alpha and Beta to be set correctly.
3. **Lookup table**: Pros: pre-calculates square roots in advance, potentially fast for repeated calculations; Cons: memory-intensive and limited scalability.
4. **** 0.5**: Pros: extremely simple and easy to implement; Cons: likely the slowest of all approaches.

**Library Usage**

In this benchmark, a custom `hypotLookup()` function is used with a lookup table. The purpose of this library is to provide an efficient way to look up pre-calculated square roots for specific input values, allowing for faster calculations.

**Special JavaScript Features or Syntax**

None are explicitly mentioned in the provided JSON. However, it's worth noting that these benchmarks rely on standard JavaScript features like functions, loops, and conditional statements.

**Other Alternatives**

For calculating square roots in JavaScript, other alternatives might include:

1. **Approximate algorithms**: There are several approximation algorithms available for computing square roots, such as Newton-Raphson or Babylonian method.
2. **Specialized libraries**: Libraries like `mathjs` or `decimal.js` provide optimized implementations of mathematical functions, including square root calculations.

Keep in mind that these alternatives might not be directly comparable to the approaches tested in this benchmark, and their performance may vary depending on specific use cases and requirements.

Related benchmarks:

Sqrt vs Alpha max plus beta min algorithm vs lookup table vs **0.5 (version: 0)

Comparing performance of: Math.sqrt() vs Alpha max plus beta min vs Lookup table vs ** 0.5

Created: 2 years ago by: Guest

Jump to the latest result