Math Tools

List the first N abundant numbers, whose proper divisors sum to more than the number itself.

List the first N almost-perfect numbers, whose proper divisors sum to exactly one less than the number.

Generate our asymmetric variant of the Cantor set, keeping an uneven 30%/50% split instead of an even middle-third removal.

Generate the first N terms of the Baum-Sweet sequence of 0s and 1s.

Generate Cantor dust, the real 2D generalization of the Cantor set, built by keeping only the 4 corner cells of a 3x3 grid at every scale.

Generate the classic middle-thirds Cantor set, stacked one row per iteration, as a downloadable SVG.

Render the Cesaro curve, a Koch-family fractal at an 85 degree turn angle that gives it a torn-paper look.

Render our hexagon-based extension of the Cesaro curve, applying its off-angle rule to six sides instead of four.

List the first N deficient numbers, whose proper divisors sum to less than the number itself.

Enter an iteration count and render the classic Heighway dragon curve as SVG line art.

Generate digits of e (Euler's number), exactly, using BigInt fixed-point arithmetic.

Generate the first N even numbers, starting from 0.

Calculate the factorial of a non-negative integer, exactly, using BigInt.

Test whether a whole number appears anywhere in the Fibonacci sequence.

Type a count and get that many Fibonacci numbers, starting from 0, 1.

Type a count and get that many Fibonacci numbers that are also prime.

Generate the Fibonacci word fractal, a turtle-drawn curve built from the Fibonacci word's 0s and 1s.

Type a character count and get that many characters of the infinite Fibonacci word.

Generate our generalized Cantor set variant, keeping 3 of 5 equal parts per iteration instead of the classic 2 of 3.

Generate N terms of Gijswijt's self-describing sequence, based on the longest repeated block in the sequence so far.

Generate digits of the golden ratio (phi), exactly, using BigInt integer square root.

Render the Gosper curve, also known as the Peano-Gosper curve or flowsnake.

Generate the classic H-tree fractal, an H shape with a smaller H centered on each of its 4 endpoints, recursively.

Enter an iteration count and render our 60-degree, triangular-angle variant of the Heighway dragon curve's turtle rules.

Render a six-fold arrangement of terdragon curves turned around a shared hexagonal center.

Enter an iteration count and render the Hilbert curve, the classic space-filling curve, as SVG line art.

Generate the Koch anti-snowflake, the Koch snowflake with every bump pointing inward instead of outward.

Generate our Koch polyflake, the classic Koch bump rule applied to a hexagon base instead of a triangle.

Generate the classic Koch snowflake, a Koch curve applied to all three sides of an equilateral triangle.

Render the single, open Koch curve, the triangular zigzag bump pattern before it's closed into a snowflake.

Generate N terms of the self-describing Kolakoski sequence over the alphabet {1, 2}.

Type an axiom and production rules, pick a turn angle and iteration count, and render the resulting turtle-graphics curve.

Render the classic Levy C curve, a self-similar fractal built from a single 45 degree turtle-graphics rule.

Generate N iterations of Conway's look-and-say sequence, starting from the seed "1".

Type a count and get that many Lucas numbers, starting from 2, 1.

Type a count and get that many Lucas numbers that are also prime.

Add two matrices element by element and get the resulting matrix.

Compute the determinant of a square matrix, up to 10x10 and beyond.

Generate an NxN identity matrix, 1s on the diagonal and 0s everywhere else.

Compute the inverse of a square matrix using Gauss-Jordan elimination.

Multiply two matrices using standard matrix multiplication.

Generate a matrix of random numbers with a chosen size and value range.

Subtract one matrix from another element by element.

Swap the rows and columns of a matrix to compute its transpose.

Render the Moore curve, a closed-loop variant of the Hilbert space-filling curve.

Generate the first N terms of the Moser-de Bruijn sequence, sums of distinct powers of 4.

Type a count and get that many negafibonacci numbers, F(-1), F(-2), F(-3), and so on.

Type a count and get that many negalucas numbers, L(-1), L(-2), L(-3), and so on.

Find every positive divisor of a number, listed in ascending order.

Generate the first N odd numbers, starting from 1.

Generate N terms of the regular paperfolding (dragon curve) sequence over {0, 1}.

Generate Pascal's Triangle to any number of rows, computed exactly with BigInt.

Render the classic Peano space-filling curve as downloadable SVG line art.

List the first N perfect numbers, whose proper divisors sum to exactly the number itself.

Generate digits of pi, exactly, using BigInt fixed-point arithmetic.

Find the prime factorization of a number, written as a product of primes.

Test whether a number is prime, with a plain-language explanation of why.

Type a count and get that many prime numbers, starting from 2.

Generate the first N terms of the Prouhet-Thue-Morse sequence over {0, 1}, based on binary digit-sum parity.

Generate the classic Pythagoras tree fractal, a square branching into two smaller squares at 45 degrees, recursively.

Render a four-fold arrangement of Heighway dragon curves turned around a shared center.

Render a right-angle Koch-family curve whose rule carves a cross or plus-sign silhouette instead of a smooth boundary.

Render the classic right-angle Koch island, a square outline built out with 90 degree notches.

Generate a sequence of random integers within a min/max range, using cryptographic randomness.

Generate the first N terms of the Rudin-Shapiro sequence of +1 and -1 values.

Render the Sierpinski arrowhead curve, a single continuous path that traces the Sierpinski triangle.

Render the classic Sierpinski carpet by recursively removing the center of a 3x3 grid.

Render the Sierpinski curve, a right-angle space-filling curve related to the Sierpinski triangle.

Generate a hexaflake, a central hexagon surrounded by 6 smaller hexagons, each scaled by one third.

Render a Sierpinski carpet subdivision as outlined corridors instead of filled cells, so it reads as a maze.

Generate a pentaflake, a central pentagon surrounded by 5 smaller pentagons, scaled by the golden ratio.

Generate our octagon-based n-flake, a central octagon surrounded by 8 smaller octagons.

Generate our square-based Sierpinski variant that drops one quadrant per level instead of a center cell.

Render the classic Sierpinski triangle by recursively subdividing a filled triangle.

Generate a fat-Cantor-set-style construction that keeps a far larger, slower-shrinking fraction of length than the classic Cantor set.

Generate the classic T-square fractal, half-size squares placed on every corner of the previous generation, recursively.

Enter an iteration count and render the terdragon curve, the ternary dragon curve built from a 120-degree turning rule, as SVG line art.

Type a character count and get that many characters of the infinite Tribonacci word.

Render our tri-fold rosette made from three Koch Star snowflakes rotated 120 degrees apart around a shared center.

Enter an iteration count and render the twindragon curve, two Heighway dragon curves joined to tile the plane, as SVG line art.

Generate a Y/V-branching recursive tree, splitting into two splayed, shrinking child branches at every generation.

Render the classic Vicsek fractal, a cross-shaped pattern built by recursively keeping the center row and column of a grid.

Generate the Z-order (Morton order) space-filling curve, visiting every cell of a grid by interleaving each cell's x and y bits.