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) {
  var s = x.toString()
  var l = s.length
  var decimalLength = s.indexOf('.') + 1

  if (l - decimalLength <= posiciones){
    return x
  }
  // 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.977777', 2)
dosDecimales
dosDecimales('17.977777')

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.

I'll break down the provided benchmark and explain what's being tested, compared options, pros and cons, and other considerations.

**Benchmark Definition**

The benchmark definition represents two JavaScript functions:

1. `dosDecimales(n)`: This function takes a string `n` as input and extracts the decimal part using a regular expression.
2. `trunc(x, posiciones = 0)`: This function truncates a given number `x` to a specified number of decimal places `posiciones`.

**Comparison Options**

The benchmark compares two approaches:

1. **dosDecimales(n)**: Extracts the decimal part using a regular expression.
2. **trunc(x, posiciones = 0)**: Truncates the number using a mathematical approach.

**Pros and Cons**

**dosDecimales(n)**

Pros:

* Simple and easy to understand
* Regular expressions can be powerful for pattern matching

Cons:

* May not perform well on very large numbers or high-performance requirements
* Can be slower due to the overhead of regular expression compilation

**trunc(x, posiciones = 0)**

Pros:

* Fast and efficient, especially for large numbers
* Avoids the overhead of regular expressions

Cons:

* More complex implementation with multiple steps
* May not be as easy to understand or maintain

**Other Considerations**

Both approaches have their trade-offs. The `dosDecimales(n)` approach is simpler but may incur performance penalties. In contrast, the `trunc(x, posiciones = 0)` approach is faster but more complex.

It's worth noting that both functions use string manipulation and mathematical operations to achieve their goals. However, the `trunc(x, posiciones = 0)` function uses a more efficient algorithm with less overhead.

**Library Usage**

Neither of the provided functions uses an external library explicitly in the benchmark definition. However, if we examine the implementation details, we can see that the `dosDecimales(n)` function uses the `match()` method, which is a part of the JavaScript String prototype. This suggests that the benchmark is testing the built-in string manipulation capabilities of JavaScript.

**Special JS Feature or Syntax**

Neither of the provided functions explicitly uses any special JavaScript features or syntax. However, it's worth noting that the `trunc(x, posiciones = 0)` function uses the exponentiation operator (`Math.pow`) to calculate the decimal place value. This is a common and efficient way to perform calculations in JavaScript.

**Alternatives**

If you're looking for alternative approaches, here are a few options:

1. **Use a library**: Consider using a library like `mathjs` or `decimal.js` that provides optimized implementations for mathematical operations.
2. **Use a different data type**: If performance is critical, consider using a floating-point number data type instead of strings to avoid the overhead of string manipulation.
3. **Optimize implementation**: Experiment with optimizing the implementation of either function to improve performance.

Keep in mind that these alternatives may introduce additional complexity or trade-offs depending on your specific use case and requirements.

Related benchmarks:

trunc-benchmark (version: 0)

trunc

Comparing performance of: trunc vs dosDecimales

Created: 8 years ago by: Guest

Jump to the latest result