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

Historical Performance Data aggregated from 10 community runs

Desktop Results:

Chrome 10 runs

FAST CEIL

18.6M/s

~~test

18.5M/s

Math.floor(test)

7.0M/s

Math.ceil(test)

7.0M/s

Math.floor(test) + 1 (CEIL)

7.0M/s

Fastest: FAST CEIL (2.7x faster)

View exact numbers

✓ FAST CEIL: 18,598,986 ops/sec
• ~~test: 18,483,350 ops/sec
• Math.floor(test): 7,049,193 ops/sec
• Math.ceil(test): 7,032,581 ops/sec
• Math.floor(test) + 1 (CEIL): 6,993,165 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

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: 5 months ago)

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

Browser/OS: Chrome 144 on Windows

View result in a separate tab

~~test

136.5M/s

Math.ceil(test)

130.1M/s

FAST CEIL

127.7M/s

Math.floor(test) + 1 (CEIL)

126.5M/s

Math.floor(test)

108.4M/s

View exact numbers

Test name	Executions per second
✓ ~~test	136,515,248 Ops/sec
Math.ceil(test)	130,052,784 Ops/sec
FAST CEIL	127,713,448 Ops/sec
Math.floor(test) + 1 (CEIL)	126,454,824 Ops/sec
Math.floor(test)	108,444,304 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one year 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.

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: 3 years ago by: Guest

Go to the latest result

Math.ceil(test)

~~test

Math.floor(test)

Math.floor(test) + 1 (CEIL)

FAST CEIL

Historical Performance Data aggregated from 10 community runs

Desktop Results:

Chrome 10 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

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: 3 years ago by: Guest

Go to the latest result

Math.ceil(test)

~~test

Math.floor(test)

Math.floor(test) + 1 (CEIL)

FAST CEIL

Historical Performance Data aggregated from 10 community runs

Desktop Results:

Chrome 10 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

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