About

Errors in sequence generation cascade. A miscalculated common difference in an arithmetic progression corrupts every subsequent term. A wrong ratio in a geometric series compounds exponentially. This generator implements exact integer arithmetic using BigInt where overflow threatens precision - particularly for factorial (n!) and Catalan numbers (C_n). It covers 12 sequence families: arithmetic, geometric, Fibonacci-type, primes (via Sieve of Eratosthenes up to bounded limits), triangular, square, cube, powers, Collatz, Catalan, factorial, and user-defined recurrences parsed without eval(). The tool approximates nothing - every term is computed from its defining formula or recurrence relation.

Limitation: custom recurrence expressions support basic arithmetic operators (+, −, ×, ÷, ^) and references to a(n−1), a(n−2), and n. Transcendental functions are not included. Prime generation uses trial division beyond sieve range, which slows above 10⁷. Pro tip: for Collatz sequences, starting values above 10⁹ may produce thousands of terms before reaching 1 - set a term limit to avoid excessive output.

Formulas

Arithmetic Sequence - a(n) = a₁ + (n − 1) ⋅ d

where a₁ is the first term, d is the common difference, n is the term index.

Geometric Sequence - a(n) = a₁ ⋅ r^{n − 1}

where r is the common ratio. Diverges when |r| ≥ 1.

Fibonacci Recurrence - F(n) = F(n − 1) + F(n − 2)

with seeds F(0) = 0, F(1) = 1. Custom seeds produce generalized Fibonacci (tribonacci, Lucas, etc.).

Triangular Numbers - T(n) = n(n + 1)2

where n ≥ 1.

Catalan Numbers - C_n = 1n + 1 (2n)!n! ⋅ n!

Computed via BigInt to avoid overflow. Counts structurally distinct full binary trees with n + 1 leaves.

Collatz Conjecture -

{

n ÷ 2 if n is even3n + 1 if n is odd

Unproven conjecture: every positive integer eventually reaches 1. Verified for all n < 2⁶⁸.

Reference Data

Sequence	Formula / Rule	First 8 Terms	OEIS ID
Arithmetic (d=3)	a(n) = a₁ + (n−1)d	1, 4, 7, 10, 13, 16, 19, 22	-
Geometric (r=2)	a(n) = a₁ ⋅ rⁿ⁻¹	1, 2, 4, 8, 16, 32, 64, 128	A000079
Fibonacci	F(n) = F(n−1) + F(n−2)	0, 1, 1, 2, 3, 5, 8, 13	A000045
Primes	Trial division / Sieve	2, 3, 5, 7, 11, 13, 17, 19	A000040
Triangular	T(n) = n(n+1)2	1, 3, 6, 10, 15, 21, 28, 36	A000217
Square Numbers	S(n) = n²	1, 4, 9, 16, 25, 36, 49, 64	A000290
Cube Numbers	C(n) = n³	1, 8, 27, 64, 125, 216, 343, 512	A000578
Powers of 2	2ⁿ	1, 2, 4, 8, 16, 32, 64, 128	A000079
Factorial	n! = n∏k=1 k	1, 1, 2, 6, 24, 120, 720, 5040	A000142
Catalan	C_n = 1n+1C(2n, n)	1, 1, 2, 5, 14, 42, 132, 429	A000108
Collatz (start 6)	n → n÷2 or 3n+1	6, 3, 10, 5, 16, 8, 4, 2	-
Lucas	L(n) = L(n−1) + L(n−2)	2, 1, 3, 4, 7, 11, 18, 29	A000032
Pentagonal	P(n) = n(3n−1)2	1, 5, 12, 22, 35, 51, 70, 92	A000326
Hexagonal	H(n) = n(2n−1)	1, 6, 15, 28, 45, 66, 91, 120	A000384
Pell	P(n) = 2P(n−1) + P(n−2)	0, 1, 2, 5, 12, 29, 70, 169	A000129

Frequently Asked Questions

The generator uses JavaScript BigInt for factorial and Catalan computations. Standard IEEE 754 doubles lose precision beyond 2^53 − 1 (approximately 9 × 10^15). Factorial of 21 already exceeds this. BigInt provides arbitrary-precision integers, so factorial of 1000 (a number with 2,568 digits) is computed exactly. The output is rendered as a string to preserve all digits.

The tool caps output at 50,000 terms. Arithmetic, geometric, square, cube, triangular, and power sequences generate in under 50ms for 50,000 terms. Prime generation via sieve handles up to approximately 10^7 efficiently; beyond that, trial division slows to roughly O(n√n). Fibonacci and custom recurrences with BigInt seeds slow proportionally to digit count. A progress indicator appears for any generation exceeding 200ms.

Yes. The parser does not use eval() or Function(). It tokenizes the input into a whitelist of allowed tokens: numeric literals, the variables a(n-1), a(n-2), n, and operators +, −, ×, ÷, ^, along with parentheses. Any unrecognized token aborts parsing with an error message. This prevents arbitrary code execution entirely.

The Collatz sequence terminates when it reaches 1 (the conjectured fixed point). Its length is unpredictable - starting from 27 produces 111 steps, while 26 produces only 10. The generator runs until reaching 1 or hitting the 50,000-term safety limit. You can also set a custom maximum term count to truncate early.

For generating the first N primes where the estimated upper bound is below 10,000,000, the tool uses the Sieve of Eratosthenes with an upper bound estimated via the prime number theorem: p(n) ≈ n × (ln(n) + ln(ln(n))). For larger requests, it falls back to incremental trial division testing each candidate against known primes up to its square root. The sieve approach runs in O(n log log n) time and is preferred.

Yes. The Fibonacci-type sequence allows custom seeds for the first two terms. Setting seed₁ = 2 and seed₂ = 1 produces the Lucas sequence (2, 1, 3, 4, 7, 11, 18, ...). Setting seed₁ = 2 and seed₂ = 6 produces the Pell-related sequence. Any pair of integers (including negatives) is accepted.