Benchmark: Math.floor() vs Lodash _.floor() vs bitwise NOT

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>

Script Preparation code:

var num = 123.4567

Tests:

Math.floor()
Math.floor(num)
Lodash _.floor()
_.floor(num)
bitwise NOT
~~num

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Math.floor()
Lodash _.floor()
bitwise NOT

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

Browser/OS: Chrome 103 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Math.floor()	7668600.0 Ops/sec
Lodash _.floor()	7914223.0 Ops/sec
bitwise NOT	23280056.0 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down the benchmark and its components, explaining what's being tested, compared options, pros and cons of each approach, and other considerations.

**Benchmark Overview**

The benchmark is designed to compare three different methods for performing rounding operations:

1. `Math.floor()`: A built-in JavaScript function that returns the largest integer less than or equal to the input value.
2. `_floor(num)`: A method from the Lodash library (version 4.17.5) that performs similar rounding as `Math.floor()` but with some differences in behavior.
3. `~num`: A bitwise NOT operation, which can be used to round down a floating-point number.

**Benchmark Test Cases**

The benchmark consists of three individual test cases:

1. `Math.floor(num)`:
	* Tests the built-in `Math.floor()` function.
2. `_floor(num)`:
	* Tests the Lodash library's `_floor()` method, which performs similar rounding as `Math.floor()`.
3. `~num`:
	* Tests the bitwise NOT operation to round down a floating-point number.

**Library: Lodash**

The Lodash library is a popular utility library for JavaScript that provides a wide range of functional programming helpers. In this benchmark, `_floor(num)` is used from version 4.17.5 of the library.

Lodash's `_floor()` method is designed to provide more flexibility and control over rounding compared to `Math.floor()`. It takes into account various edge cases, such as negative numbers, zero, and very large or small values.

**Bitwise NOT Operation (`~num`)**

The bitwise NOT operation is a low-level approach that can be used to round down a floating-point number by converting it to an integer. This method relies on the binary representation of the number, where rounding up would require adding 1 to the binary representation.

However, this approach has some limitations:

* It may not work correctly for negative numbers or zero.
* It may not produce the expected results for very large or small values due to integer overflow or underflow issues.
* It can be slower and less efficient compared to using `Math.floor()` or `_floor(num)`.

**Comparison of Options**

Here's a brief comparison of the three options:

| Method | Pros | Cons |
| --- | --- | --- |
| `Math.floor()` | Built-in, fast, reliable | May not handle edge cases correctly |
| `_floor(num)` (Lodash) | Flexible, handles edge cases, but slower than built-in methods | Additional dependency required |
| `~num` (bitwise NOT) | Low-level, simple implementation, but may have limitations | Slow, unreliable for certain inputs |

**Other Considerations**

When choosing between these options, consider the specific use case and requirements:

* If speed is a critical factor, using `Math.floor()` might be the best choice.
* If flexibility and control over rounding are required, `_floor(num)` from Lodash might be a better option.
* For simple cases where rounding up or down is not necessary, the bitwise NOT operation (`~num`) could be an acceptable solution.

Keep in mind that this benchmark is designed to compare these specific methods, but there may be other approaches available for performing rounding operations in JavaScript.

Related benchmarks:

Math.floor() vs Lodash _.floor() vs bitwise NOT (version: 0)

Math.floor() vs Lodash _.floor() vs bitwise NOT

Comparing performance of: Math.floor() vs Lodash _.floor() vs bitwise NOT

Created: 2 years ago by: Guest

Jump to the latest result

Math.floor()

Lodash _.floor()

bitwise NOT

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):