Benchmark: get precision from number string

Script Preparation code:

function generateRandomDecimalInRangeFormatted(min, max) {
    let value = (Math.random() * (max - min + 1)) + min;
    return Number.parseFloat(value).toFixed(Math.random() * 10);
}

var size = 100;

var arr = [];

for (i = 0; i < size; i++) {
    arr.push(generateRandomDecimalInRangeFormatted(0, 1));
}

Tests:

utility
function removeTrailingZeroAndDots( value, removeDots = false ) { if (!value) return ''; let result = typeof value === 'number' ? String(value) : value; result = result // Remove decimal 0. `1.000` => `1.`, `1.100` => `1.1`, `1.000` => `1.0` .replace(/(\.\d*[^0])0*$/, '$1') // Remove useless decimal. `1.0` => `1.` or `1`, `1.` => `1` .replace(/\.0*$/, removeDots ? '' : '.'); return result; }; function getPrecision(str) { return removeTrailingZeroAndDots(str)?.split('.')[1]?.length || 0 } for (i = 0; i < size; i++) { const precision = getPrecision(arr[i]); console.log(precision) }
log
function getLog10Precision(str) { const precision = Math.log10(Number(str)) * -1; return precision; } for (i = 0; i < size; i++) { const precision = getLog10Precision(arr[i]); console.log(precision) }
e
function getEPrecision(value) { const num = typeof value === 'string' ? +value : value if (!isFinite(num)) return 0; var e = 1, p = 0; while (Math.round(num * e) / e !== num) { e *= 10; p++; } return p; } for (i = 0; i < size; i++) { const precision = getEPrecision(arr[i]); console.log(precision) }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
utility
log
e

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the explanation of what is being tested on MeasureThat.net.

**Benchmark Definition**

The benchmark definition provides the context for the test cases. In this case, we're testing three different functions to determine the precision (decimal places) of numbers in strings, ignoring trailing zeroes and decimal points. The functions are:

1. `removeTrailingZeroAndDots`
2. `getLog10Precision`
3. `getEPrecision`

**Options Compared**

The three functions differ in their approach to calculate precision:

1. **`removeTrailingZeroAndDots`**: This function removes trailing zeros and decimal points from the input string, then returns the length of the resulting string as the precision.
2. **`getLog10Precision`**: This function uses the logarithm base 10 to calculate the precision by converting the number to a string, taking the logarithm, and multiplying by -1.
3. **`getEPrecision`**: This function estimates the precision using Euler's totient function, which counts the number of positive integers up to a given number that are relatively prime to that number.

**Pros and Cons**

Here's a brief summary of each approach:

* `removeTrailingZeroAndDots`:
	+ Pros: simple and straightforward
	+ Cons: may not work correctly for non-numeric input or very large numbers
* `getLog10Precision`:
	+ Pros: robust and accurate, but slower due to logarithm calculation
	+ Cons: requires numerical computations, which can be slow
* `getEPrecision`:
	+ Pros: fast and efficient, but may not be accurate for all inputs
	+ Cons: relies on an estimate, which may not always produce the correct result

**Library Usage**

None of the functions use external libraries.

**Special JavaScript Features/Syntax**

There are no special JavaScript features or syntax mentioned in this benchmark.

**Other Alternatives**

If you were to implement a new function for calculating precision, other alternatives could include:

* Using regular expressions to remove trailing zeroes and decimal points
* Utilizing the `decimal` library for precise decimal arithmetic
* Implementing a more advanced algorithm, such as using the `big.js` library for large numbers

Keep in mind that each alternative has its own trade-offs in terms of performance, accuracy, and complexity.

The benchmark results show that the order of execution is:

1. `getEPrecision`
2. `removeTrailingZeroAndDots`
3. `getLog10Precision`

The average executions per second for each test case are:

* `utility`: 709.603
* `log`: 702.890
* `e`: 651.056

These results suggest that `getEPrecision` is the fastest, followed by `removeTrailingZeroAndDots`, and then `getLog10Precision`. However, please note that these results are specific to this benchmark and may not be representative of other use cases or implementations.

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36

Browser/OS: Chrome 92 on Linux

View result in a separate tab

Test name	Executions per second
utility	709.6 Ops/sec
log	702.9 Ops/sec
e	651.1 Ops/sec

Related benchmarks:

get precision from number string (version: 5)

with ignoring trailing zeroes, the function should return the precision (decimal places) of a number (decimal or non-decimal)

Comparing performance of: utility vs log vs e

Created: 3 years ago by: Registered User

Jump to the latest result

utility

log

e

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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