Fibonacci Calculator - nth Term, Sum, and Golden Ratio

A fibonacci calculator is a tool that reads a positive integer n and returns the nth Fibonacci number, the full term list, the sum of the first n terms, and the consecutive ratio that approaches the golden ratio. It is meant for students, programmers, and anyone who needs an exact Fibonacci value with a closed-form cross-check.

• • Find the nth Fibonacci number: Type n and read F(n) directly instead of hand-walking a recurrence.
• • Generate a clean term list: Print F(1) through F(n) as a comma-separated list you can paste into notes.
• • Sum the first n Fibonacci terms: Read the running total of the first n terms, equal to F(n+2) - 1.
• • See the golden ratio converge: Compare the consecutive ratio F(n) / F(n - 1) against phi to see the limit in action.

The Fibonacci sequence is the most famous recursive sequence in school math. Every term after the first two is the sum of the two previous terms, so the sequence is fully determined by its seed values. The calculator does the recurrence in your browser and prints a Binet result next to the iterative result so you can see they agree.

For a sequence that adds a fixed step instead of a recursive sum, the Arithmetic Sequence Calculator handles the arithmetic progression case with the same n, a1, d inputs.

The calculator runs the recurrence F(n) = F(n - 1) + F(n - 2) iteratively and prints the closed-form Binet's formula result next to it as a cross-check. The seed values are 1 and 1 for the 1-indexed convention or 0 and 1 for the 0-indexed convention.

• n: Index of the term to compute. Must be a positive integer; the calculator accepts n from 1 to 1000.
• F(1), F(2): Seed values, equal to 1 and 1 in the 1-indexed convention used by default.
• phi: Golden ratio (1 + sqrt(5)) / 2, approximately 1.6180339887498949.
• psi: Conjugate root (1 - sqrt(5)) / 2, approximately -0.6180339887498949.
• F(n): The nth Fibonacci number; the primary output of the calculator.

The iterative result and the Binet result run in parallel so any disagreement surfaces immediately. The iterative path uses standard JavaScript numbers for small n and integer accumulation for the running sum to keep the total exact, while the Binet path uses phi and psi to fifteen decimals and rounds at the end.

According to Wolfram MathWorld, the Fibonacci numbers are defined by the recurrence F(n) = F(n-1) + F(n-2) with F(0) = 0 and F(1) = 1, and Binet's closed form is F(n) = (phi^n - psi^n) / sqrt(5).

The Binet cross-check uses the same kind of closed-form trick you see in n! in the Factorial Calculator, which reduces a recursive product to a single expression.

Four ideas cover every output the calculator prints and every choice the user can make in the form.

The recurrence is the smallest possible definition of a non-trivial integer sequence, which is why it shows up in textbooks, coding interviews, and biology discussions of plant growth patterns. The golden ratio is a by-product of the recurrence, not a separate input: once the calculator prints the consecutive ratio, you can read it against the reference phi row to see how close the sequence is to the limit at the chosen n.

When you want to compare two general numbers as a ratio, the Ratio Calculator handles the same divide-and-simplify workflow without assuming the numerator is a Fibonacci number.

Five short steps cover every workflow the calculator supports, from a homework problem to a quick golden-ratio sanity check.

1. 1 Type the index n: Enter the positive integer whose Fibonacci value you want. The default n = 10 prints the classic 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 list.
2. 2 Pick the starting convention: Choose the 1-indexed seed (F(1) = 1, F(2) = 1) for the textbook list, or the 0-indexed seed (F(0) = 0, F(1) = 1) for a leading zero.
3. 3 Read the nth term and the Binet cross-check: The F(n) row is the iterative result; the Binet row is the same value in closed form.
4. 4 Scan the term list and the sum: The term list is capped at the first 50 terms, and the sum row is the running total, equal to F(n + 2) - 1.
5. 5 Compare the consecutive ratio to phi: The F(n) / F(n - 1) row shows how close the last two terms are to the golden ratio. By n = 20 the ratio is within 0.0001% of phi.

Practical example - a coding-interview sanity check: you have just written a recursive function that returns Fibonacci(n) and want to know it works. Type n = 10 with the 1-indexed seed. The F(n) row should print 55, the term list should end with 55, the sum row should print 143, and the Binet row should also print 55.

When the Fibonacci terms are the side lengths of nested squares, the Spiral Length Calculator computes the arc length of the spiral that runs through them.

The calculator removes the most common Fibonacci mistakes and saves the step of looking up the closed-form identities in a textbook.

• • Iterative and closed-form in one pass: The F(n) row and the Binet row print at the same time, so you can verify a recursive function against the closed form.
• • Exact arithmetic for large n: The sum row uses integer accumulation and the nth term is rounded from Binet, so the printed integers stay exact up to n = 1000.
• • Both starting conventions supported: Switching the seed values shifts the printed list and the labeling without changing the numbers from F(1) onward.
• • Golden ratio is shown, not assumed: The consecutive ratio row and the reference phi row put the famous limit on screen so you can read it.
• • Domain errors are explained: If n is 0, negative, or a decimal, the calculator returns a clear message instead of NaN.
• • Pairs with related math tools: The term list is the kind of output a recursive coding exercise prints, and the consecutive ratio is a special case of the ratio calculator.

It is plain JavaScript in the browser, so the fibonacci calculator updates as you type, tolerates both seed conventions, and stays readable even when n is much larger than a hand calculation would handle.

If you want to test whether the printed Fibonacci terms are prime, the Prime Number Checker applies a Miller-Rabin-style check to the same integers.

Three inputs change what the calculator prints, plus two practical caveats about how Binet's formula and the term list behave for large n.

• • Binet's formula uses standard IEEE 754 double precision in this browser, so the closed-form row is only exact up to about n = 70. The iterative F(n) row and the sum row stay exact up to n = 1000 because they use integer arithmetic.
• • The visible term list is capped at 50 terms to keep the result panel readable. The exact nth term and the sum of the first n terms are still computed for larger n, but a list of 200 integers would dominate the page.

The starting convention is a presentation choice that does not change the values, so use the convention that matches the textbook or the coding exercise you are working through. For most school and coding tasks, n stays well under 70 and Binet is exact; when n is larger, treat the Binet row as a sanity check rounded to the nearest integer and trust the iterative F(n) row for the exact value.

According to Wikipedia (Fibonacci sequence), the sum of the first n Fibonacci numbers equals F(n+2) - 1, and the ratio of consecutive Fibonacci numbers approaches the golden ratio phi as n grows.

When you want to see the same recursive structure for binary strings, the Binary Operations Calculator applies a recursive definition to a different data type.