Benchmark: Reduce vs bitwise dividing

Tests:

Reduce
function s(x) { return x.toString().split('').reduce((total, cur) => total += parseInt(cur), 0); } let x = s(123456789);
Dividing
function s(x) { let sum = 0; while (x > 0) { sum += x % 10; x = Math.floor(x / 10) } return sum; } let x = s(123456789);
bitwise dividing
function s(x) { let sum = 0; while (x > 0) { sum += x % 10; x = ~~(x / 10) } return sum; } let x = s(123456789);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Reduce
Dividing
bitwise dividing

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Linux; Android 11; Pixel 3a) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.141 Mobile Safari/537.36

Browser/OS: Chrome Mobile 87 on Android

View result in a separate tab

Test name	Executions per second
Reduce	265650.4 Ops/sec
Dividing	284223.5 Ops/sec
bitwise dividing	20011900.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what's being tested.

**Benchmark Definition**

The benchmark defines two different approaches to calculate the sum of digits in a given number: using the `reduce()` method (also known as "Reduce") and using bitwise division. The benchmark uses JavaScript functions, each returning a single value representing the sum of digits.

**Options Compared**

Two options are compared:

1. **Reduce**: This approach uses the `reduce()` method, which iterates over an array-like object (in this case, the string representation of the number) and applies a callback function to each element, accumulating the result.
2. **Bitwise Dividing**: This approach uses bitwise operations to extract the individual digits from the number and then sums them up.

**Pros and Cons**

**Reduce:**

Pros:

* Easy to implement and understand
* Built-in in JavaScript, so no extra dependencies required

Cons:

* May have performance overhead due to the `reduce()` method's iteration mechanism
* Can be slower than other approaches for very large numbers

**Bitwise Dividing:**

Pros:

* Typically faster than using `reduce()`, especially for large numbers
* Uses basic arithmetic operations, which are often optimized by JavaScript engines

Cons:

* Requires a good understanding of bitwise operations and how to extract digits from an integer
* May require more code and be harder to maintain than the `reduce()` approach

**Library Use**

None of the benchmark cases use any external libraries.

**Special JS Features or Syntax**

The benchmark uses the `~~` operator, which is not a standard JavaScript operator. It's an example of a "bitwise trick" used to perform integer division without the decimal part:

`x = ~~(x / 10)`

This operator performs floor division (`Math.floor(x / 10)`), which discards any fractional part.

**Other Alternatives**

For calculating the sum of digits, other alternatives could include:

* Using `String.prototype.split()` and `Array.prototype.reduce()`
* Implementing a custom loop using basic arithmetic operations
* Using assembly language or native code (if the benchmark is highly optimized for performance)

However, these alternatives would likely require more expertise in JavaScript and are not as straightforward to implement as the `reduce()` approach.

**Benchmark Result Interpretation**

The latest benchmark result shows that the "bitwise dividing" approach outperforms both "Reduce" approaches, with an average of 284,223.46875 executions per second. This suggests that bitwise division is a more efficient method for calculating the sum of digits in this specific scenario.

Keep in mind that these results are highly dependent on the specific JavaScript engine and platform used by the benchmark.

Related benchmarks:

Reduce vs bitwise dividing (version: 0)

Comparing performance of: Reduce vs Dividing vs bitwise dividing

Created: 3 years ago by: Registered User

Jump to the latest result

Reduce

Dividing

bitwise dividing

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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