Benchmark: toFixed vs toPrecision vs Math.round() fast vs Math.floorfast vs new Math.trunc

toFixed vs toPrecision vs Math.round() fast vs Math.floorfast vs new Math.trunc (version: 0)

Comparing performance of: toFixed(4) vs toPrecision(4).toString() vs (~~Math.round(*10000)).toString() vs Math.floor fast vs the new Math.trunc

Comparing performance of: toFixed(4) someFloat.toFixed(4); someFloat.t vs toPrecision(4).toString() vs ~(someFloat*1000)/-1000 vs Math.floor fast vs Math.trunc

Created: 2 years ago by: Guest

Jump to the latest result

Script Preparation code:

var someFloat = 0.123456789;

Tests:

toFixed(4) someFloat.toFixed(4); someFloat.t
someFloat.toFixed(4);
toPrecision(4).toString()
someFloat.toPrecision(4);
~(someFloat*1000)/-1000
~(someFloat*1000)/-1000
Math.floor fast
~~(someFloat * 10000) / 10000;
Math.trunc
Math.trunc(someFloat * 10000) / 10000;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
toFixed(4) someFloat.toFixed(4); someFloat.t
toPrecision(4).toString()
~(someFloat*1000)/-1000
Math.floor fast
Math.trunc

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

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

**Benchmark Definition**

The test compares the performance of five different methods for rounding or truncating numbers:

1. `toFixed(4)`: Rounds a number to 4 decimal places.
2. `toPrecision(4).toString()`: Converts a number to a string with a precision of 4 digits.
3. `(~~Math.round(*10000)).toString()`: Uses the bitwise NOT operator (`~`) to round down a large number to the nearest integer, and then converts it to a string.
4. `Math.floor fast`: A shortened version of `Math.floor()` that is optimized for performance.
5. `Math.trunc(someFloat * 10000) / 10000`: Uses the `Math.trunc()` function to truncate a large number.

**Options compared**

Each option has its pros and cons:

* `toFixed(4)` and `toPrecision(4).toString()`: These methods are simple and easy to understand, but may not be as efficient for large numbers. They also require more CPU cycles than some of the other options.
* `(~~Math.round(*10000)).toString()`: This method uses a bitwise NOT operator to round down the number, which can be slower than other methods. However, it is often used in JavaScript because it is simple and works well for many cases.
* `Math.floor fast`: As mentioned earlier, this is an optimized version of `Math.floor()`. It is likely faster than the other options but may require more complex code to implement.
* `Math.trunc(someFloat * 10000) / 10000`: This method uses `Math.trunc()` to truncate the number, which can be slower than some other methods. However, it is a more straightforward way to round down a large number.

**Library usage**

In this benchmark, the following libraries are used:

* `Math` library: Used for mathematical functions such as `toFixed()`, `toPrecision()`, `round()`, and `trunc()`.
* `~~`: This is not a standard JavaScript operator. It uses the bitwise NOT operator (`~`) to round down a number, which is not recommended for production code.
* `toString()`: Used to convert numbers or strings to a string representation.

**Special JS feature**

The benchmark uses the `~~` operator, which is not a standard JavaScript operator. While it works in some cases, it is generally considered bad practice due to potential performance issues and unexpected results.

**Other alternatives**

If you need to round or truncate numbers in JavaScript, here are some alternative methods:

* Use `Math.floor()` or `Math.ceil()` for rounding down or up.
* Use `Number.EPSILON` to compare floating-point numbers for equality.
* Use a library like `decimal.js` for precise decimal arithmetic.

In summary, the benchmark compares the performance of five different methods for rounding or truncating numbers in JavaScript. While each method has its pros and cons, `Math.floor fast` is likely the fastest option, while `(~~Math.round(*10000)).toString()` may be slower but is often used due to simplicity.

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/605.1.15 (KHTML, like Gecko) Version/14.1.2 Safari/605.1.15

Browser/OS: Safari 14 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
toFixed(4) someFloat.toFixed(4); someFloat.t	10640115.0 Ops/sec
toPrecision(4).toString()	9127618.0 Ops/sec
~(someFloat*1000)/-1000	25795182.0 Ops/sec
Math.floor fast	25780622.0 Ops/sec
Math.trunc	10552778.0 Ops/sec

Related benchmarks:

toFixed vs toPrecision vs Math.round() fast vs Math.floorfast vs new Math.trunc (version: 0)

Comparing performance of: toFixed(4) vs toPrecision(4).toString() vs (~~Math.round(*10000)).toString() vs Math.floor fast vs the new Math.trunc

Comparing performance of: toFixed(4) someFloat.toFixed(4); someFloat.t vs toPrecision(4).toString() vs ~(someFloat*1000)/-1000 vs Math.floor fast vs Math.trunc

Created: 2 years ago by: Guest

Jump to the latest result

toFixed(4) someFloat.toFixed(4); someFloat.t

toPrecision(4).toString()

~(someFloat*1000)/-1000

Math.floor fast

Math.trunc

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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