Benchmark: Math.log10() vs .toString().length

Tests:

Math.log10(), .floor()
let num = 5000; let nums = []; for(let i = 1; i <= num; ++i) { nums.push(Math.floor(Math.log10(i))); }
Math.log10(), OR
let num = 5000; let nums = []; for(let i = 1; i <= num; ++i) { nums.push(Math.log10(i) | 0); }
.toString().length
let num = 5000; let nums = []; for(let i = 1; i <= num; ++i) { nums.push(i.toString().length - 1); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Math.log10(), .floor()
Math.log10(), OR
.toString().length

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down what's being tested in the provided JSON benchmark.

**What is being tested?**

The main goal of this benchmark is to compare the performance of three different approaches:

1. `Math.log10()` followed by `.floor()`
2. `Math.log10()` with a bitwise OR operator (`| 0`)
3. `.toString().length` (converting numbers to strings)

**Options compared:**

The first two options are variations of using `Math.log10()`. The difference lies in how the result is further processed:

* Option 1 uses `Math.floor()` to round down the result to an integer.
* Option 2 uses a bitwise OR operator (`| 0`) to truncate the decimal part of the result.

The third option, `.toString().length`, converts numbers to strings and measures the length of that string.

**Pros and cons:**

1. **Option 1 (Math.log10() + .floor())**: This is likely the most straightforward approach. It's simple to read and understand. However, it might incur a small overhead due to the function call.
2. **Option 2 (Math.log10() OR)**: This option uses bitwise operations, which can be faster than function calls in some cases. However, it may be less readable and more prone to errors due to the unconventional use of bitwise operators for this purpose.
3. **Option 3 (.toString().length)**: This approach has a significant overhead due to string conversion and length calculation. It's likely to be slower than both options 1 and 2.

**Library and special JS features:**

* No external libraries are used in these benchmarks.
* There is no use of special JavaScript features like async/await, promises, or ES modules.

**Other considerations:**

* The benchmark uses a `for` loop to iterate from 1 to `num`, which can be slow due to the overhead of incrementing the loop variable.
* The results are measured in executions per second, which is a common metric for performance benchmarks.

**Alternatives:**

If you want to explore alternative approaches or variations on these options, you could try:

* Using other mathematical functions like `Math.log()` instead of `Math.log10()`.
* Comparing the performance of different rounding modes (e.g., `Math.round()`, `Math.ceil()`, etc.).
* Investigating the impact of different iteration methods (e.g., `for...of`, `while`, etc.) on performance.
* Adding more complex inputs or edge cases to test the robustness of each approach.

Keep in mind that optimizations like these might not be immediately apparent and may require additional investigation.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36

Browser/OS: Chrome 131 on Windows

View result in a separate tab

Test name	Executions per second
Math.log10(), .floor()	953.4 Ops/sec
Math.log10(), OR	1662.0 Ops/sec
.toString().length	27023.5 Ops/sec

Related benchmarks:

Math.log10() vs .toString().length (version: 0)

Comparing performance of: Math.log10(), .floor() vs Math.log10(), OR vs .toString().length

Created: one year ago by: Guest

Jump to the latest result

Math.log10(), .floor()

Math.log10(), OR

.toString().length

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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