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

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

Comparing performance of: toFixed(4) vs toPrecision(4).toString() vs (Math.round(*10000)/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 (Math.round(*10000)/10000).toString() vs Math.floor fast vs Math.trunc

Created: 6 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);
(Math.round(*10000)/10000).toString()
(Math.round(someFloat*10000)/10000);
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()
(Math.round(*10000)/10000).toString()
Math.floor fast
Math.trunc

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 4 months ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:146.0) Gecko/20100101 Firefox/146.0

Browser/OS: Firefox 146 on Windows

View result in a separate tab

Test name	Executions per second
toFixed(4) someFloat.toFixed(4); someFloat.t	34969596.0 Ops/sec
toPrecision(4).toString()	28639676.0 Ops/sec
(Math.round(*10000)/10000).toString()	3342448128.0 Ops/sec
Math.floor fast	3090065664.0 Ops/sec
Math.trunc	3350657792.0 Ops/sec

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

LLMs can make mistakes. Check important info.

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

**Benchmark Definition**

The benchmark is testing the performance of different methods to round or truncate a floating-point number:

1. `toFixed(4)`: This method rounds the number to 4 decimal places using the "fixed" rounding mode.
2. `toPrecision(4).toString()`: This method uses the `toPrecision()` method to specify the precision and then converts the result to a string.
3. `(Math.round(*10000)/10000).toString()`: This method multiplies the number by 10,000, rounds the result using `Math.round()`, and then divides by 10,000 before converting to a string.
4. `~~(someFloat * 10000) / 10000`: This method uses bitwise NOT (`~`) to effectively truncate the number (more on this later).
5. `Math.trunc(someFloat * 10000) / 10000`: This method uses the new `Math.trunc()` function (introduced in ECMAScript 2020) to truncate the number.

**Options Compared**

The benchmark is comparing these five different methods:

* `toFixed(4)` vs `toPrecision(4).toString()`: These two methods use different rounding modes, but both aim to achieve a similar result.
* `(Math.round(*10000)/10000).toString()` vs `~~(someFloat * 10000) / 10000`: Both methods use bitwise operations or multiplication/division by large numbers to truncate the number.
* `(Math.round(*10000)/10000).toString()` vs `Math.trunc(someFloat * 10000) / 10000`: The first method uses a more traditional rounding approach, while the second method uses the new `Math.trunc()` function.

**Pros and Cons**

Here's a brief summary of each method:

* `toFixed(4)`:
	+ Pros: Easy to use, straightforward.
	+ Cons: May not work as expected for very large numbers or non-integer results.
* `toPrecision(4).toString()`:
	+ Pros: More precise than `toFixed(4)`, but may be slower due to the extra conversion step.
	+ Cons: Can be less intuitive for some users, as it relies on the `toPrecision()` method.
* `(Math.round(*10000)/10000).toString()`:
	+ Pros: Simple and effective, but may not work well with very large or very small numbers.
	+ Cons: Uses multiplication/division by large numbers, which can be slower than other methods.
* `~~(someFloat * 10000) / 10000`:
	+ Pros: Fast and efficient, as it uses bitwise NOT to truncate the number.
	+ Cons: May not work well with very large or very small numbers due to integer overflow/underflow issues.
* `Math.trunc(someFloat * 10000) / 10000`:
	+ Pros: More precise than `~~(someFloat * 10000) / 10000`, and easier to read for some users.
	+ Cons: May be slower due to the division step, but is generally faster than the traditional rounding methods.

**Library and Special JS Features**

The benchmark uses the following library:

* None explicitly mentioned. However, `Math.trunc()` is a new function introduced in ECMAScript 2020, which provides an efficient way to truncate numbers without using bitwise operations.

If any special JavaScript features are used, they might be implicit in the `~~(someFloat * 10000) / 10000` method, as it relies on the `~` operator (bitwise NOT). This feature was introduced in ECMAScript 2015.

**Alternatives**

Other alternatives for rounding or truncating numbers include:

* Using a library like `lodash` or `moment.js`, which provide more complex and powerful rounding functions.
* Implementing a custom rounding function using arithmetic operations, as done in the `~~(someFloat * 10000) / 10000` method.
* Using a different data type, such as an integer, to represent the rounded/truncated number.

Keep in mind that the choice of rounding method depends on the specific use case and requirements.

Related benchmarks: