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

toFixed vs toPrecision vs Math.round() vs Math.floorfast vs new Math.trunc vs numeraljs (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 vs numeraljs

Created: 3 years ago by: Guest

Jump to the latest result

HTML Preparation code:

<script src="//cdnjs.cloudflare.com/ajax/libs/numeral.js/2.0.6/numeral.min.js"></script>

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;
numeraljs
numeral(someFloat).format('0.0000');

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
numeraljs

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**Overview of the Benchmark**

The provided benchmark measures the performance of different methods for rounding and formatting decimal numbers in JavaScript. The test cases compare the execution time of various functions, including `toFixed`, `toPrecision`, `Math.round`, `Math.floor fast` (a shorthand for `~~(someFloat * 10000) / 10000`), `Math.trunc`, and a library-based function using Numeral.js.

**Methods Compared**

1. **`toFixed(4)`**: Rounds the number to 4 decimal places.
	* Pros: Simple, straightforward implementation.
	* Cons: May not be suitable for all precision requirements.
2. **`toPrecision(4).toString()`**: Formats the number as a string with 4 significant digits.
	* Pros: More flexible than `toFixed`, can handle different precision requirements.
	* Cons: Requires an extra conversion to string, may impact performance.
3. **`(Math.round(someFloat * 10000) / 10000).toString()`**: Rounds the number using `Math.round` and then divides by 10000.
	* Pros: Simple, straightforward implementation.
	* Cons: May not be as accurate as other methods, especially for large numbers.
4. **`Math.floor fast` (shorthand for `~~(someFloat * 10000) / 10000`)**: Rounds the number using the bitwise NOT operator (`~`) to truncate it.
	* Pros: Very fast implementation, suitable for high-performance applications.
	* Cons: May not be suitable for all precision requirements, can produce rounding errors.
5. **`Math.trunc`**: Rounds the number to the nearest integer.
	* Pros: Fast implementation, suitable for high-performance applications.
	* Cons: May not be suitable for decimal numbers.
6. **`numeral(someFloat).format('0.0000')` (using Numeral.js)**: Formats the number as a string with 6 decimal places using the Numeral.js library.
	* Pros: More flexible than other methods, can handle different precision requirements.
	* Cons: Requires an external library, may impact performance.

**Library Used**

The `numeraljs` library is used in one of the test cases to format the number as a string with 6 decimal places. Numeral.js provides a convenient and flexible way to work with numbers, but it does require an external library.

**Special JavaScript Feature/Syntax**

None mentioned in this benchmark.

**Other Alternatives**

Other alternatives for rounding and formatting decimal numbers in JavaScript include:

* Using the `Number.EPSILON` constant to determine the smallest representable floating-point value.
* Implementing a custom rounding algorithm using bitwise operations, such as `~~` or `<< 1`.
* Using a library like Moment.js or Luxon to work with dates and numbers.

**Benchmark Results**

The benchmark results show that the execution times vary depending on the method used. The fastest methods are `Math.floor fast` and `Math.trunc`, while `toFixed(4)` and `toPrecision(4).toString()` are slower due to the extra conversions required. The Numeral.js implementation is also slower than the native JavaScript implementations.

Note that these results may vary depending on the specific browser, platform, and hardware used for running the benchmark.

Latest run results:

Run details: (Test run date: 3 years ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0.3 Safari/605.1.15

Browser/OS: Safari 14 on Mac OS X 10.15.6

View result in a separate tab

Test name	Executions per second
toFixed(4) someFloat.toFixed(4); someFloat.t	5881193.0 Ops/sec
toPrecision(4).toString()	4739471.5 Ops/sec
(Math.round(*10000)/10000).toString()	4675021.5 Ops/sec
Math.floor fast	12324935.0 Ops/sec
Math.trunc	4709398.0 Ops/sec
numeraljs	483498.4 Ops/sec

Related benchmarks:

toFixed vs toPrecision vs Math.round() vs Math.floorfast vs new Math.trunc vs numeraljs (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 vs numeraljs

Created: 3 years ago by: Guest

Jump to the latest result

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

toPrecision(4).toString()

(Math.round(*10000)/10000).toString()

Math.floor fast

Math.trunc

numeraljs

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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