Benchmark: fib test 1111 - MeasureThat.net

HTML Preparation code:

<script>
function fiboLoop(num){
  var a = 1, b = 0, temp;

  while (num >= 0){
    temp = a;
    a = a + b;
    b = temp;
    num--;
  }

  return b;
}

function fiboRec(num) {
  if (num <= 1) return 1;

  return fiboRec(num - 1) + fiboRec(num - 2);
}

function fiboMemo(num, memo) {
  memo = memo || {};

  if (memo[num]) return memo[num];
  if (num <= 1) return 1;

  return memo[num] = fiboMemo(num - 1, memo) + fiboMemo(num - 2, memo);
}
</script>

Tests:

reg
fiboLoop(20)
recursive
fiboRec(20)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
reg
recursive

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

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

**Benchmark Definition**

The benchmark is testing two different implementations of the Fibonacci sequence calculation: `fiboLoop` and `fiboRec`. The Fibonacci sequence is a series of numbers where each number is the sum of the two preceding ones, usually starting with 0 and 1.

There's also an alternative implementation called `fiboMemo`, which uses memoization to store previously calculated values. Memoization is a technique used to speed up computations by caching intermediate results.

**Options Compared**

The benchmark compares three options:

1. **Loop-based approach (fiboLoop)**: This implementation uses a while loop to calculate the Fibonacci sequence.
2. **Recursive approach (fiboRec)**: This implementation uses recursive function calls to calculate the Fibonacci sequence.
3. **Memoized approach (fiboMemo)**: This implementation uses memoization to store previously calculated values and reuse them instead of recalculating.

**Pros and Cons**

* **Loop-based approach (fiboLoop)**:
	+ Pros: Can be faster for large inputs due to its iterative nature, less risk of stack overflow errors.
	+ Cons: May not be as efficient if the loop has a lot of overhead or is prone to branching.
* **Recursive approach (fiboRec)**:
	+ Pros: Can be easier to implement and understand, but may lead to performance issues with large inputs due to recursive calls and potential stack overflows.
	+ Cons: Can be slower than iterative approaches, more memory-intensive due to the recursive call stack.
* **Memoized approach (fiboMemo)**:
	+ Pros: Can significantly speed up calculations for repeated values by reusing previously computed results.
	+ Cons: May require more memory to store the memoization cache, can lead to increased complexity if not implemented carefully.

**Library and Special JS Features**

The benchmark definition uses no external libraries. However, it does utilize some special JavaScript features:

* **Arrow functions**: The `fiboMemo` implementation uses arrow functions for concise syntax.
* **Closures**: Some of the implementations use closures (e.g., `fiboLoop`) to encapsulate variables and avoid global variable pollution.

**Other Alternatives**

For calculating Fibonacci sequences, other approaches include:

* **Matrix exponentiation**: This method has a time complexity of O(log n) but is more complex to implement.
* **Fast doubling**: This method uses a binary exponentiation technique to calculate the Fibonacci sequence in logarithmic time.
* **Iterative matrix multiplication**: Similar to the recursive approach but using iterative matrix multiplication.

Keep in mind that these alternatives may have their own trade-offs and may not be as straightforward to understand or implement.

For this specific benchmark, the choice of implementation (loop-based, recursive, or memoized) will depend on factors such as performance requirements, input size, and the level of complexity desired.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.3071.115 Safari/537.36

Browser/OS: Chrome 59 on Windows

View result in a separate tab

Test name	Executions per second
reg	3941320.8 Ops/sec
recursive	11875.8 Ops/sec

Related benchmarks:

fib test 1111 (version: 0)

Comparing performance of: reg vs recursive

Created: 7 years ago by: Guest

Jump to the latest result

reg

recursive

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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