Benchmark: Compare Performance Code Complexity Without Original

Script Preparation code:

var n = 8;

Tests:

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 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.

**Overview**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks. The provided JSON represents two benchmark test cases, each testing different approaches for calculating the nth Fibonacci number.

**Benchmark Definition**

The benchmark definition consists of three parts:

1. **Script Preparation Code**: This code initializes the variable `n` with the value 8.
2. **Html Preparation Code**: This field is empty, indicating that no HTML preparation code is required.
3. **Description**: This field is also empty, suggesting that there is no description or context for the benchmark.

**Options Compared**

The two test cases compare the performance of two approaches:

1. **Using Go Bottom Up**: This approach uses a bottom-up dynamic programming technique to calculate the nth Fibonacci number. The function `getNthNumber` initializes three variables (`prev`, `afterPrev`, and `current`) and then iterates from 1 to `n` to calculate the value of `current`.
2. **Using Memoization**: This approach uses memoization, a technique where previously calculated values are stored in an array (`memoize`) to avoid redundant calculations. The function `getNthNumber` defines a recursive function `cb` that calculates the nth Fibonacci number by recursively calling itself with decreasing values of `n`.

**Pros and Cons**

* **Using Go Bottom Up**: This approach is likely to be slower than memoization due to the overhead of iterative calculation and variable assignments. However, it can be beneficial for smaller inputs or when memory is limited.
* **Using Memoization**: This approach is generally faster since it avoids redundant calculations by storing previously computed values. However, it requires more memory to store the `memoize` array.

**Library and Special JS Features**

Neither of the test cases uses any external libraries or special JavaScript features beyond the standard syntax and built-in functions (e.g., `for`, `let`, `const`, etc.).

**Other Alternatives**

Some alternative approaches for calculating Fibonacci numbers include:

* **Iterative Approach**: An iterative approach without memoization can be faster than the Go Bottom Up method but slower than memoization.
* **Recursive Approach with Memoization**: This approach combines recursive calculation with memoization to reduce redundant calculations, potentially offering a balance between performance and memory usage.

Keep in mind that these alternatives are not explicitly tested on MeasureThat.net.

Latest run results:

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

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

Browser/OS: Chrome 118 on Windows

View result in a separate tab

Test name	Executions per second
Using Go Bottom Up	1048120.1 Ops/sec
Using Memoization	2788020.0 Ops/sec

Related benchmarks:

Compare Performance Code Complexity Without Original (version: 0)

Comparing performance of: Using Go Bottom Up vs Using Memoization

Created: one year ago by: Guest

Jump to the latest result

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):