Benchmark: Compare Performance to find fibonacci

Script Preparation code:

var n = 8;

Tests:

Using Common Recrusive
function getNthNumber() { if(n <= 2) return 1; return getNthNumber(n - 1) + getNthNumber(n - 2) } getNthNumber()
Using Go Bottom Up
function getNthNumber() { let prev = 0; let afterPrev = 1; let current = 1; for(let i = 1; i <= n; i++) { current = prev + afterPrev afterPrev = prev prev = current } return current } getNthNumber()
Using Memoization
function getNthNumber() { const memoize = []; const cb = (n) => { if(n <= 2 ) return 1; if(memoize[n]) return memoize[n]; memoize[n] = cb(n - 1) + cb(n - 2); return memoize[n]; } return cb(n) } getNthNumber()

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Using Common Recrusive
Using Go Bottom Up
Using Memoization

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON data and explain what's being tested, compared, and their pros and cons.

**Benchmark Definition**

The benchmark is designed to compare the performance of three different approaches to calculate the nth Fibonacci number:

1. **Using Common Recursive**: This approach uses a recursive function to calculate the nth Fibonacci number.
2. **Using Go Bottom Up**: This approach uses a loop-based approach, also known as "bottom-up" method, to calculate the nth Fibonacci number.
3. **Using Memoization**: This approach uses memoization (caching) to store previously calculated Fibonacci numbers and reuse them instead of recalculating.

**Options Compared**

The three approaches are compared in terms of their execution time (measured in executions per second).

**Pros and Cons of Each Approach:**

1. **Common Recursive**:
	* Pros:
		+ Simple to implement
	* Cons:
		+ High memory usage due to recursive calls
		+ Slow performance as the function call stack grows with increasing input size
2. **Go Bottom Up**:
	* Pros:
		+ Efficient use of memory (no recursive calls)
		+ Fast performance for large input sizes
	* Cons:
		+ More complex implementation compared to the common recursive approach
3. **Memoization**:
	* Pros:
		+ Good balance between simplicity and efficiency (compared to bottom-up method)
		+ Can handle large input sizes with reasonable memory usage
	* Cons:
		+ Requires additional memory for caching previously calculated Fibonacci numbers

**Library Used**

There is no explicit library mentioned in the provided JSON data. However, it's worth noting that the memoization approach uses a simple array to store cached results, which is not typically considered a separate library.

**Special JS Feature or Syntax**

None of the approaches use any special JavaScript features or syntax beyond what is required for basic programming (e.g., function definitions, loops).

**Alternatives**

Other alternatives for calculating Fibonacci numbers include:

1. **Matrix Exponentiation**: This approach uses matrix multiplication to calculate Fibonacci numbers in O(log n) time.
2. **Fast Double Recursion**: This approach uses a combination of recursive and loop-based techniques to achieve better performance than traditional recursive methods.
3. **Iterative Method with Loop**: This approach uses a simple loop to calculate Fibonacci numbers without using recursion.

Keep in mind that these alternatives may have their own trade-offs in terms of complexity, memory usage, and performance.

I hope this explanation helps! Let me know if you have any further questions.

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36

Browser/OS: Chrome 118 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Using Common Recrusive	0.0 Ops/sec
Using Go Bottom Up	3344790.5 Ops/sec
Using Memoization	7129469.0 Ops/sec

Related benchmarks:

Compare Performance to find fibonacci (version: 0)

Comparing performance of: Using Common Recrusive vs Using Go Bottom Up vs Using Memoization

Created: one year ago by: Guest

Jump to the latest result

Using Common Recrusive

Using Go Bottom Up

Using Memoization

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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