Benchmark: Math.floorfast with addition

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;
Math.floor fast with addition
~~((someFloat + 1) * 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
Math.floor fast with addition

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and its test cases.

**Benchmark Description**
The benchmark measures the performance difference between various methods for rounding or truncating floating-point numbers in JavaScript. The main objective is to determine which method is the fastest.

**Test Cases**

1. `someFloat.toFixed(4);` vs `toFixed(4) someFloat.toFixed(4); someFloat.t`
This test case compares the performance of using `toFixed()` with precision 4 directly on a floating-point number (`someFloat`) versus calling `toFixed()` twice on the same number, followed by assigning the result to a variable `someFloat.t`. The intention is to check if there's any overhead associated with assigning the result back to a variable.

2. `toPrecision(4);` vs `toPrecision(4).toString()`
This test case compares the performance of using `toPrecision()` with precision 4 directly on a floating-point number (`someFloat`) versus calling `toPrecision()` once and then converting the result to a string using `toString()`.

3. `(Math.round(someFloat*10000)/10000);` vs `(Math.round(*10000)/10000).toString()`
This test case compares the performance of manually rounding a floating-point number by multiplying, rounding, and dividing by 10,000 versus calling `Math.round()` with a scaled value.

4. `~~(someFloat * 10000) / 10000;` vs `Math.floor fast`
This test case compares the performance of using integer comparison (`~~`) to truncate a floating-point number multiplied by 10,000 versus calling `Math.floor()` directly on the same operation.

5. `Math.trunc(someFloat * 10000) / 10000;` vs `Math.trunc`
This test case compares the performance of using `Math.trunc()` with a scaled value versus calling `Math.trunc()` directly on the same operation.

**Library Used: None**

All tests use native JavaScript methods and operators, which are built-in to the language.

**Special JS Feature/Syntax:**
None mentioned in the provided test cases. However, it's worth noting that some browsers may have specific optimizations or behaviors for certain JavaScript features, but this is not explicitly highlighted in these benchmarks.

**Other Alternatives:**

In general, there are alternative methods to achieve similar results:

* For rounding numbers:
	+ Using decimal arithmetic libraries (e.g., Decimal.js)
	+ Implementing custom rounding algorithms
	+ Utilizing specialized libraries for financial or scientific calculations
* For truncating numbers:
	+ Using integer comparison operators (`~~` or `>>`)
	+ Implementing custom truncation algorithms
	+ Utilizing specialized libraries for numerical computations

For these specific benchmarks, the focus is on measuring the performance of built-in JavaScript methods versus alternative approaches.

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/15.3 Safari/605.1.15

Browser/OS: Safari 15 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	7241430.5 Ops/sec
toPrecision(4).toString()	6067501.5 Ops/sec
(Math.round(*10000)/10000).toString()	8385662.5 Ops/sec
Math.floor fast	20434120.0 Ops/sec
Math.trunc	8373019.0 Ops/sec
Math.floor fast with addition	20489840.0 Ops/sec

Related benchmarks:

Math.floorfast with addition (version: 0)

performance difference to fast floor

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 Math.floor fast with addition

Created: 4 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

Math.floor fast with addition

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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