Benchmark: Compare Performance to find fibonacci 2

Script Preparation code:

var n = 8;

AخA
 
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()

​x
 
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()

 
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

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

Test case name	Result
Using Go Bottom Up
Using Memoization

Fastest: N/A

Slowest: N/A

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 Go Bottom Up	3338467.0 Ops/sec
Using Memoization	7016766.5 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):

Benchmark Overview

The provided JSON represents a benchmark for comparing the performance of two approaches to calculate the nth Fibonacci number: "Go Bottom Up" and "Memoization". The benchmark is designed to test how efficiently each approach can compute Fibonacci numbers.

Options Compared

Two options are compared:

Go Bottom Up: This approach uses a bottom-up dynamic programming technique. It starts with the base cases (Fibonacci numbers 0 and 1) and iteratively calculates subsequent numbers by summing the previous two.
Memoization: This approach uses memoization, a caching mechanism that stores the results of expensive function calls to avoid redundant calculations.

Pros and Cons

Go Bottom Up:
- Pros: Simple to implement, efficient for large inputs.
- Cons: May use excessive memory for large inputs due to the recursive nature of the calculation.
Memoization:
- Pros: Can handle large inputs efficiently by caching results, reduces redundant calculations.
- Cons: Requires additional memory for storing cache values.

Library/Functionality

In this benchmark, no external libraries or functions are used besides JavaScript. The getNthNumber() function is a custom implementation of the Fibonacci number calculation for each approach.

Special JS Features/Syntax

There are no special JavaScript features or syntax used in these benchmarks. They only utilize basic JavaScript constructs such as loops, variables, and functions.

Alternative Approaches

Other approaches to calculate the nth Fibonacci number include:

Recursive Approach: A top-down dynamic programming technique that uses recursion to calculate Fibonacci numbers.
Iterative Approach with Lookahead: An optimization of the bottom-up approach by calculating multiple subsequent numbers in each iteration.
Matrix Exponentiation: A mathematical technique for calculating Fibonacci numbers using matrix exponentiation, which has a time complexity of O(log n).

These alternative approaches may have different performance characteristics and use cases compared to the "Go Bottom Up" and "Memoization" approaches tested in this benchmark.

LLMs can make mistakes. Check important info.

**Benchmark Overview**

**Options Compared**

Two options are compared:

1. **Go Bottom Up**: This approach uses a bottom-up dynamic programming technique. It starts with the base cases (Fibonacci numbers 0 and 1) and iteratively calculates subsequent numbers by summing the previous two.
2. **Memoization**: This approach uses memoization, a caching mechanism that stores the results of expensive function calls to avoid redundant calculations.

**Pros and Cons**

* **Go Bottom Up**:
	+ Pros: Simple to implement, efficient for large inputs.
	+ Cons: May use excessive memory for large inputs due to the recursive nature of the calculation.
* **Memoization**:
	+ Pros: Can handle large inputs efficiently by caching results, reduces redundant calculations.
	+ Cons: Requires additional memory for storing cache values.

**Library/Functionality**

In this benchmark, no external libraries or functions are used besides JavaScript. The `getNthNumber()` function is a custom implementation of the Fibonacci number calculation for each approach.

**Special JS Features/Syntax**

There are no special JavaScript features or syntax used in these benchmarks. They only utilize basic JavaScript constructs such as loops, variables, and functions.

**Alternative Approaches**

Other approaches to calculate the nth Fibonacci number include:

* **Recursive Approach**: A top-down dynamic programming technique that uses recursion to calculate Fibonacci numbers.
* **Iterative Approach with Lookahead**: An optimization of the bottom-up approach by calculating multiple subsequent numbers in each iteration.
* **Matrix Exponentiation**: A mathematical technique for calculating Fibonacci numbers using matrix exponentiation, which has a time complexity of O(log n).

These alternative approaches may have different performance characteristics and use cases compared to the "Go Bottom Up" and "Memoization" approaches tested in this benchmark.

Related benchmarks:

Compare Performance to find fibonacci 2 (version: 0)

Comparing performance of: Using Go Bottom Up vs Using Memoization

Created: one year ago by: Guest

Jump to the latest result