Benchmark: trunc-benchmark - MeasureThat.net

Script Preparation code:

function dosDecimales(n) {
  let t=n.toString();
  let regex=/(\d*.\d{0,2})/;
  return t.match(regex)[0];
}

function trunc (x, posiciones = 0) {
  // Parte decimal del número
  var isNeg  = x < 0
  var decimal =  x % 1
  var entera  = isNeg ? Math.ceil(x) : Math.floor(x)
  // Parte decimal como número entero
  // Ejemplo: parte decimal = 0.77
  // decimalFormated = 0.77 * (10^posiciones)
  // si posiciones es 2 ==> 0.77 * 100
  // si posiciones es 3 ==> 0.77 * 1000
  var decimalFormated = Math.floor(
    Math.abs(decimal) * Math.pow(10, posiciones)
  )
  // Sustraemos del número original la parte decimal
  // y le sumamos la parte decimal que hemos formateado
  var finalNum = entera + 
    ((decimalFormated / Math.pow(10, posiciones))*(isNeg ? -1 : 1))
  
  return finalNum
}

Tests:

trunc
trunc('17.97777', 2)
dosDecimales
dosDecimales('17.97777')

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
trunc
dosDecimales

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

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

**Benchmark Definition**

The benchmark definition represents two different JavaScript functions:

1. `dosDecimales(n)`: This function takes a string `n` as input, converts it to a number, extracts the decimal part using a regular expression, and returns the extracted decimal part as a string.
2. `trunc(x, posiciones = 0)`: This function takes two arguments: `x` (a number) and an optional `posiciones` parameter (default value is 0). It calculates the decimal part of the input number `x`, formats it to a specific number of decimal places using the `posiciones` parameter, and returns the original number with the decimal part replaced by the formatted value.

**Options being compared**

The benchmark compares two different approaches:

1. `dosDecimales(n)` (the "extract-and-format" approach)
2. `trunc(x, posiciones = 0)` (the "replace-decimal-part" approach)

**Pros and Cons of each approach:**

1. **Extract-and-format approach (`dosDecimales(n)`)**:
	* Pros:
		+ Easy to implement and understand.
		+ Works for any input number with a fixed decimal place format.
	* Cons:
		+ May not be efficient for large numbers or high-performance applications, as it involves creating a regular expression object and using `match()` method.
2. **Replace-decimal-part approach (`trunc(x, posiciones = 0)`)**:
	* Pros:
		+ More efficient than the extract-and-format approach, especially for large numbers or high-performance applications, since it only requires basic arithmetic operations.
	* Cons:
		+ May be more difficult to implement and understand due to its complexity.

**Library used**

The `dosDecimales(n)` function uses a regular expression object (`regex`) to extract the decimal part of the input string. The regular expression `/\\d*.\\d{0,2}/` matches one or more digits (`\\d*`) followed by an optional two-digit decimal number (`\\d{0,2}`). The `match()` method is then used to extract the matched substring.

**Special JS feature or syntax**

There is no special JS feature or syntax being used in this benchmark. Both functions use standard JavaScript concepts and data types.

**Other alternatives**

If you were to implement these benchmarks from scratch, other alternatives to consider:

1. Use a dedicated library like `mathjs` for numerical computations.
2. Implement the decimal part extraction using a different approach, such as using bitwise operations or arithmetic shifts.
3. Use a more efficient algorithm for formatting the decimal part, such as using a lookup table.

However, since these are simple benchmark cases, the built-in JavaScript functions should be sufficient for comparison purposes.

Keep in mind that this is just a brief analysis of the provided benchmarks. If you'd like to explore further optimization or implementation details, I can help with that!

Related benchmarks:

trunc-benchmark (version: 0)

trunc

Comparing performance of: trunc vs dosDecimales

Created: 8 years ago by: Guest

Jump to the latest result