Benchmark: Math.ceil vs floor vs ~~

Script Preparation code:

var test = 190.4;

Tests:

Math.ceil(test)
Math.ceil(test)
~~test
~~test
Math.floor(test)
Math.floor(test)
Math.floor(test) + 1 (CEIL)
Math.floor(test) + 1
FAST CEIL
~~test + 1

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Math.ceil(test)
~~test
Math.floor(test)
Math.floor(test) + 1 (CEIL)
FAST CEIL

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 4 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 Edg/131.0.0.0

Browser/OS: Chrome 131 on Windows

View result in a separate tab

Test name	Executions per second
Math.ceil(test)	2284793.2 Ops/sec
~~test	5143756.0 Ops/sec
Math.floor(test)	2571221.2 Ops/sec
Math.floor(test) + 1 (CEIL)	2449174.0 Ops/sec
FAST CEIL	4882958.0 Ops/sec

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

LLMs can make mistakes. Check important info.

**What is being tested?**

On MeasureThat.net, users can create and run JavaScript microbenchmarks to compare the performance of different approaches. In this benchmark, four mathematical functions are being compared:

1. `Math.ceil(test)`: Returns the smallest integer greater than or equal to `test`.
2. `~~test` (also known as bitwise NOT): Returns the result of casting `test` to an integer using two's complement arithmetic.
3. `Math.floor(test)`: Returns the largest integer less than or equal to `test`.
4. `Math.floor(test) + 1`: This is a variant of `Math.ceil(test)` that uses addition instead of taking the ceiling.

**Options compared**

The benchmark compares four options:

* `~~test` (bitwise NOT)
* `Math.ceil(test)`
* `Math.floor(test)`
* `Math.floor(test) + 1`

**Pros and Cons of each approach:**

1. `~~test`:
	* Pros: Can be faster than the other approaches for certain types of numbers, as it uses bitwise operations.
	* Cons: May not work correctly for negative numbers or numbers outside the range of two's complement arithmetic.
2. `Math.ceil(test)`:
	* Pros: Is a standard JavaScript function that is widely supported and can handle any type of number.
	* Cons: May be slower than `~~test` for certain types of numbers, as it involves more complex calculations.
3. `Math.floor(test)`:
	* Pros: Similar to `Math.ceil(test)`, but returns the largest integer less than or equal to `test`.
	* Cons: May also be slower than `~~test` for certain types of numbers.
4. `Math.floor(test) + 1`:
	* Pros: Is a variant of `Math.ceil(test)` that uses addition instead of taking the ceiling, which can make it slightly faster.
	* Cons: Can lead to integer overflow if `test` is a large number.

**Library used**

None

**Special JS feature or syntax used**

The `~~` operator is not a standard JavaScript operator. It is an older syntax for casting a value to an integer using two's complement arithmetic, which was widely supported in the past but has since been deprecated. MeasureThat.net uses this syntax to compare its performance with `Math.ceil(test)`.

**Other considerations**

Measuring the performance of different mathematical approaches can be useful for optimizing code or writing more efficient algorithms. However, it's also important to consider other factors such as readability, maintainability, and bug safety when choosing an approach. In general, using established standard library functions like `Math.ceil()` and `Math.floor()` is a good idea unless there is a specific reason to use a custom implementation.

**Alternatives**

Other alternatives for calculating the ceiling of a number include:

* Using the `Math.round()` function with `Number.EPSILON` to simulate rounding up
* Writing a custom implementation using bitwise operations, as mentioned earlier
* Using a third-party library or plugin that provides faster ceiling calculations

However, these alternatives may not be suitable for all use cases and should be carefully evaluated before adoption.

Related benchmarks:

Math.ceil vs floor vs ~~ (version: 0)

Comparing performance of: Math.ceil(test) vs ~~test vs Math.floor(test) vs Math.floor(test) + 1 (CEIL) vs FAST CEIL

Created: one year ago by: Guest

Jump to the latest result

Math.ceil(test)

~~test

Math.floor(test)

Math.floor(test) + 1 (CEIL)

FAST CEIL

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