#math

Combinatorics maths as an API, computed locally and deterministically with exact arbitrary-precision integers. The factorial endpoint computes n! = 1·2·3···n (with 0! = 1) and returns it exactly as a string together with its digit count, so even very large factorials stay precise. The permutations endpoint counts ordered arrangements: without repetition nPr = n!/(n−r)! arrangements of r items chosen from n, and with repetition n^r, where each of the r positions may be any of the n items. The combinations endpoint counts unordered selections: without repetition the binomial coefficient nCr = n!/(r!·(n−r)!), and with repetition (multisets) C(n+r−1, r), where repeats are allowed. All results are computed with BigInt so they are exact no matter how large, returned as a string with the number of digits and a floating-point approximation when it fits. n and r are non-negative integers up to 100000. Everything is computed locally and deterministically, so it is instant and private. Ideal for probability, statistics, lottery, game-design, cryptography and education app developers, counting and odds tools, and discrete-maths teaching. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is counting combinatorics; for modular arithmetic use a modular API and for descriptive statistics a statistics API.

api.oanor.com/combinatorics-api

Modular-arithmetic maths as an API, computed locally and deterministically with exact big-integer arithmetic. The power endpoint computes modular exponentiation, aᵇ mod m, by square-and-multiply, fast and exact even for the huge exponents used in cryptography. The inverse endpoint finds the modular multiplicative inverse a⁻¹ mod m with the extended Euclidean algorithm, returning the inverse when a and m are coprime and reporting the gcd when no inverse exists. The totient endpoint computes Euler's totient φ(n) — the count of integers from 1 to n coprime to n — with the prime factorization it comes from, and an optional Euler-theorem check that a^φ(n) ≡ 1 (mod n) for a coprime base. These are the building blocks of RSA and much of modern cryptography. Inputs are integers and can be passed as strings for very large values. Everything is computed locally and deterministically, so it is instant and private. Ideal for cryptography, security, blockchain and mathematics app developers, RSA and number-theory tools, and computer-science education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is modular arithmetic; for prime factorization and GCD use a number-theory API and for integer sequences a sequences API.

api.oanor.com/modular-api

Complex-number maths as an API, computed locally and deterministically. The arithmetic endpoint adds, subtracts, multiplies or divides two complex numbers z₁ = a + bi and z₂ = c + di, returning the result in both rectangular (a + bi) and polar (modulus ∠ angle) form. The properties endpoint describes a single complex number — its modulus |z| = √(a² + b²), its argument in radians and degrees, its conjugate, its negation, its reciprocal and its polar form. The power endpoint applies De Moivre's theorem, zⁿ = rⁿ(cos nθ + i·sin nθ), to raise a complex number to any real power, and for a positive integer n it also returns all n distinct n-th roots, evenly spaced around the complex plane. The imaginary part defaults to zero, so real inputs work too. Everything is computed locally and deterministically, so it is instant and private. Ideal for engineering, signal-processing, electronics, physics and mathematics app developers, AC-circuit and phasor tools, and STEM education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is complex-number arithmetic; for plane-angle unit conversion use an angle API and for vectors a vector API.

api.oanor.com/complexnumber-api

Interpolation maths as an API, computed locally and deterministically. The linear endpoint interpolates between two points, y = y0 + (y1 − y0)·(x − x0)/(x1 − x0), returning the value at a target x (or, given a target y, solving the x that produces it), the parameter t and whether the point lies outside the segment. The table endpoint does piecewise-linear interpolation within a table of (x, y) points supplied as comma-separated lists — it sorts the points, finds the two that bracket your query and interpolates between them, extending the nearest segment and flagging the result when you query outside the data range, ideal for calibration curves and lookup tables. The bilinear endpoint interpolates on a rectangular grid from four corner values, interpolating along x at each y-edge and then along y. Everything is computed locally and deterministically, so it is instant and private, and unlike regression it passes exactly through the supplied points. Ideal for engineering, data-visualisation, gaming, mapping and scientific-computing app developers, lookup-table and calibration tools, and numerical-methods education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is interpolation; for least-squares regression and correlation use a statistics API.

api.oanor.com/interpolation-api

Triangle-solving maths as an API, computed locally and deterministically. The solve endpoint solves any triangle from three values — three sides (SSS), two sides and the included angle (SAS), two angles and a side (ASA/AAS), or the ambiguous two-sides-and-a-non-included-angle case (SSA) — using the law of cosines and the law of sines, and returns all three sides and angles, the perimeter, the Heron area and whether the triangle is acute, right or obtuse and equilateral, isosceles or scalene; for an ambiguous SSA input it also returns the second valid triangle. The right endpoint is a dedicated right-triangle solver from any two of the two legs, the hypotenuse and an acute angle, applying Pythagoras and basic trigonometry. The points endpoint builds a triangle from three cartesian vertices, giving the side lengths, the interior angles, the shoelace area and the centroid. Angles are in degrees. Everything is computed locally and deterministically, so it is instant and private. Ideal for education, CAD, surveying, game-development and engineering app developers, geometry and trigonometry tools, and STEM teaching. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This solves triangles; for areas and volumes of general shapes use a geometry API and for polygon point-set operations a polygon API.

api.oanor.com/triangle-api

Scientific number representation as an API. The scientific endpoint expresses a number in both scientific notation (one digit before the decimal point × a power of ten) and engineering notation (the exponent a multiple of three, lining up with SI prefixes), and reports the mantissa and exponent. The sigfigs endpoint rounds a number to a chosen number of significant figures, and counts the significant figures in a value — respecting the rules for leading zeros, trailing zeros and the decimal point, and flagging the ambiguous cases such as "1200". The si-prefix endpoint formats a number with the right metric prefix (1500 → 1.5 k, 2.3×10⁹ → 2.3 G, 0.0023 → 2.3 m) with an optional unit, and parses a prefixed value back to a plain number (2.2 MΩ → 2,200,000). Everything is computed locally and deterministically, so it is instant and private. Ideal for science and engineering tools, lab and measurement software, electronics and signal work, and education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 4 endpoints. This is scientific number representation; for locale number formatting use a number-format API and for number-to-words or Roman numerals use a number API.

api.oanor.com/sigfig-api

Convert integers and numbers into the special number representations that ordinary base conversion leaves out — and back again. The graycode endpoint converts between an integer and its reflected binary Gray code, where consecutive values differ by exactly one bit (used in rotary encoders, Karnaugh maps and error reduction). The balanced-ternary endpoint converts between an integer and balanced ternary, the base-3 system with digits −1, 0 and +1 (written T, 0, 1) that needs no separate sign. The factoradic endpoint converts between an integer and the factorial number system (mixed radix 1, 2, 3, …), the basis of permutation ranking and Lehmer codes. The continued-fraction endpoint turns a fraction or a real number into its continued-fraction expansion [a0; a1, a2, …] and lists the convergents — the successively best rational approximations — and can rebuild the value from the terms. All integer maths is exact via big integers. Everything is computed locally and deterministically, so it is instant and private. Ideal for computer-science teaching, combinatorics and permutation ranking, error-correcting and encoder design, rational approximation, and recreational mathematics. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 5 endpoints. This handles special number representations; for ordinary base 2-36 conversion use a base-convert API.

api.oanor.com/numrep-api

Work with polynomials: find their roots, evaluate them, differentiate and integrate, and add, subtract, multiply or divide them. The roots endpoint returns every root — real and complex — using the exact quadratic formula for degree 2 and the Durand-Kerner method for higher degrees, with a clean list of just the real roots too. The evaluate endpoint computes p(x) and p'(x) at a point by Horner's method. The derivative endpoint returns the coefficients of the derivative and of the indefinite integral. The operate endpoint does polynomial arithmetic — addition, subtraction, multiplication, and long division giving a quotient and a remainder. Coefficients are given highest-degree first, so [1,-3,2] means x² − 3x + 2. Everything is computed locally and deterministically, so it is instant and private. Ideal for engineering and control systems, signal processing and filter design, computer graphics and curve fitting, scientific computing, and teaching algebra and calculus. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 5 endpoints. This is polynomial maths; for matrices and linear systems use a matrix API, for vectors a vector API, and for general arithmetic a math API.

api.oanor.com/polynomial-api

Linear algebra as an API: multiply matrices, analyse a matrix, and solve linear systems — all computed locally and exactly. The multiply endpoint returns the product A×B, checking that the inner dimensions match. The analyze endpoint takes any matrix and returns its transpose and rank, and for square matrices also the determinant, trace, whether it is symmetric and invertible, and the inverse when it exists — using LU decomposition with partial pivoting and Gauss-Jordan elimination for numerical stability. The solve endpoint solves a system Ax = b for a square coefficient matrix by Gaussian elimination with partial pivoting, and reports cleanly when the matrix is singular and there is no unique solution. Matrices are passed as JSON arrays of rows, for example [[1,2],[3,4]]. Everything is deterministic and instant. Ideal for data-science and machine-learning prep, computer graphics and 3D transforms, engineering and physics, computer-vision calibration, control systems, and teaching linear algebra. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 4 endpoints. This is matrix and linear-algebra maths; for 3D rotations use a quaternion API, for vector maths use a vector API, and for statistics use a stats API.

api.oanor.com/matrix-api

3D rotation maths as an API: convert freely between quaternions, Euler angles, axis-angle and rotation matrices, compose rotations, rotate vectors, and interpolate. The convert endpoint takes any one representation — a quaternion {w,x,y,z}, Euler angles (roll, pitch, yaw), an axis and angle, or a 3×3 matrix — and returns all four forms at once, normalized. The multiply endpoint composes two quaternions (the Hamilton product) so you can chain rotations. The rotate endpoint applies a quaternion to a 3D vector. The slerp endpoint does spherical linear interpolation between two orientations along the shortest path — the standard way to animate smooth rotations. Euler angles use the aerospace Z-Y-X (yaw-pitch-roll) intrinsic convention in degrees; quaternions follow the Hamilton convention with order w,x,y,z; matrices are row-major right-handed. Everything is computed locally and deterministically, so it is instant and private. Ideal for game and graphics engines, robotics and drones, IMU and sensor fusion, aerospace and flight dynamics, VR/AR, and 3D content tooling. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 5 endpoints. This is 3D rotation maths; for 2D geometry use a geometry API and for plain angle-unit conversion use an angle API.

api.oanor.com/quaternion-api

Evaluate boolean-logic expressions and generate complete truth tables. The table endpoint takes a boolean expression, finds its variables, builds every row of the truth table (the first variable is the most-significant bit, the standard convention), and returns each row's values and result, the list of minterms (the row indices where the expression is true), a classification of tautology / contradiction / contingency, and a canonical sum-of-products (SOP) form. The evaluate endpoint computes the expression's value for one specific assignment of its variables. It understands the full set of operators in both symbol and word form — NOT (!, ~, ¬), AND (&, &&, ∧, *, ., AND), OR (|, ||, ∨, +, OR), XOR (^, ⊕), NAND, NOR, XNOR, implication (->, =>, →, IMPLIES) and the biconditional (<->, <=>, ↔, IFF) — with the usual precedence (NOT > AND > XOR > OR > IMPLIES > IFF), parentheses, and the constants 0/1 and true/false. Everything is computed locally and deterministically, so it is instant and private. Ideal for digital-logic and discrete-math teaching, hardware and HDL design, simplifying conditions in code, SAT-style sanity checks, and interview prep. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This evaluates boolean logic and builds truth tables; for arithmetic and equations use a math API.

api.oanor.com/truthtable-api

Inspect and build IEEE 754 floating-point numbers — see exactly how a number is stored in the bits. The encode endpoint takes a number and decomposes its single (32-bit) or double (64-bit) representation into the sign bit, the raw and unbiased exponent, the mantissa, the full binary layout split into sign / exponent / mantissa, the hexadecimal word, and a classification (normal, subnormal, zero, infinity or NaN); for single precision it also returns the actual value after rounding, so you can see floating-point error directly. The decode endpoint goes the other way — give it a hex word or a 32-/64-bit binary string and it returns the number it represents along with the same field breakdown. It accepts inf, -inf and nan, and lays bytes out big-endian. Everything is computed locally and deterministically, so it is instant and exact. Ideal for systems and embedded programming, teaching how floats work, debugging precision and rounding bugs, binary protocols and file formats, and interview prep. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This inspects floating-point bits; for integer base conversion use a base-convert API.

api.oanor.com/ieee754-api

Mapeia números entre intervalos. O endpoint scale mapeia linearmente um valor de um intervalo de entrada [in_min, in_max] para um intervalo de saída [out_min, out_max] — o clássico map() que você usa com leituras de sensores, sliders e knobs, medidores e barras de progresso, e eixos de visualização de dados. Ele também retorna a posição t de 0 a 1, então com o intervalo de saída padrão 0–1 ele normaliza um valor, e com um intervalo de entrada 0–1 ele interpola (lerp); intervalos de saída podem ser invertidos (out_min maior que out_max) para inverter a direção, e um clamp opcional mantém o resultado dentro do intervalo de saída em vez de extrapolar. O endpoint clamp restringe um valor a um mínimo e máximo e pode adicionalmente ajustá-lo ao passo mais próximo. Tudo é matemática local exata, instantânea e determinística. Ideal para IoT e embarcados (estilo Arduino map), áudio e DSP, gráficos e desenvolvimento de jogos, dashboards e gráficos, e controles de UI. Computação local pura — sem chave, sem serviço de terceiros, instantâneo. Ao vivo, nada armazenado. 3 endpoints. Isto mapeia valores escalares — para interpolar vetores use uma API de vetores e para curvas de easing de animação use uma API de easing.

api.oanor.com/remap-api

Exact fraction maths with arbitrary-precision integers — no floating-point rounding. The simplify endpoint reduces any fraction to its lowest terms and returns the decimal value, the mixed-number form (10/4 → 2 1/2) and whether it is a whole number. The calc endpoint adds, subtracts, multiplies or divides two values — given as fractions (1/2), whole numbers, mixed numbers (1 1/2) or decimals (0.5) — and returns the simplified result. The fromdecimal endpoint turns a decimal into a fraction: exactly for terminating decimals, and precisely for repeating decimals written with parentheses, so 0.(3) becomes 1/3 and 0.1(6) becomes 1/6. Because every step uses big integers, results are always exact and very large numerators or denominators are returned as strings rather than losing precision. Ideal for education and maths tools, recipes and unit scaling, engineering and woodworking measurements, finance, and anywhere fractions must stay exact. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 4 endpoints. This is fraction maths; for general expressions use a math-engine API and for prime factorization use a number-theory API.

api.oanor.com/fraction-api

Generate famous integer sequences and test membership, with exact big-integer maths. The generate endpoint returns the first N terms of a sequence — Fibonacci, Lucas, prime numbers, triangular, square, cube, factorial, Catalan, pentagonal and tetrahedral numbers, plus parameterised arithmetic (a start and a step), geometric (a start and a ratio) and powers (any base). The contains endpoint tells you whether a given number belongs to a sequence — is 233 a Fibonacci number, is 21 triangular, is 97 prime, is 720 a factorial — using fast closed-form tests for primes, squares, cubes, triangular, pentagonal and Fibonacci numbers and an exact search for the rest, and it returns the term index where it is known. Because everything is computed with arbitrary-precision integers, terms beyond the usual floating-point limit are returned exactly as decimal strings and never overflow. It runs entirely locally, so it is instant, deterministic and private. Ideal for education and maths tooling, coding challenges and puzzles, test-data generation, recreational mathematics and number-theory experiments. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This generates and tests integer sequences; to factorize a single number or get its divisors use a number-theory API.

api.oanor.com/sequences-api

A 2D, 3D and n-dimensional vector maths toolkit. The op endpoint performs the operation you ask for on one or two vectors: add and subtract, scale by a factor, negate, the dot product, the cross product (a vector in 3D, the scalar z-component in 2D), the magnitude (length), the unit (normalized) vector, the Euclidean distance and the angle between two vectors (in both radians and degrees), linear interpolation (lerp) between two vectors, and the projection of one vector onto another. The info endpoint analyses a single vector — its dimension, magnitude, unit vector and, for 2D, its heading angle from the x-axis. Vectors are just comma-separated components like 3,4 or 1,2,3, and operations work in any dimension up to 32 (cross product is 2D/3D only). Everything is exact local maths, so it is instant and deterministic. Ideal for game and physics engines, graphics and WebGL/canvas, robotics and navigation, data-visualisation, simulations and engineering tools. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This does vector algebra; for plane-angle unit conversion use the Angle API and for shape area/perimeter use the Geometry API.

api.oanor.com/vector-api

Evaluate animation easing and timing functions. The sample endpoint computes any of the 31 standard Penner easings — easeInOutCubic, easeOutBounce, easeInOutElastic, easeInBack, easeOutExpo, easeInOutSine and the rest — the four CSS keywords (ease, ease-in, ease-out, ease-in-out), or your own CSS cubic-bezier(x1,y1,x2,y2) timing function, solved exactly with Newton-Raphson. Ask for a single progress value t, or pass steps=N to get a ready-made table of {t, value} points for building keyframes, sprite timelines, scroll animations and interpolation lookup tables. The list endpoint returns every supported easing name with the cubic-bezier for the CSS keywords. Eased values may overshoot below 0 or above 1 for back, elastic and bounce, exactly as designers expect. Ideal for motion design, game and UI animation, CSS and canvas/WebGL tooling, charting and data-viz transitions, and anywhere you need a precise timing curve without pulling in a library. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This computes the curve values; to convert colours or build gradients use the colour and gradient APIs.

api.oanor.com/easing-api

An integer toolkit as an API. Factorize any number into its prime factors with exponents (and a readable 2^3 × 3^2 × 5 form), with the divisor count, the divisor sum, the full list of divisors and whether the number is perfect; find the greatest common divisor and least common multiple of two numbers (and whether they are coprime); and test primality, returning the next and previous prime. Handles numbers up to a trillion. Perfect for maths education and puzzles, cryptography demos, generating test data and any time you need the building blocks of a number. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 4 endpoints. A focused integer toolkit, distinct from a general math-expression engine.

api.oanor.com/numbertheory-api

Everyday percentage maths as an API. Four clear operations: what is X% of a value (15% of 200 = 30); what percentage one number is of another (30 is 15% of 200); the percentage change between two numbers, with the direction and the raw difference (200 → 250 is a 25% increase); and applying a percentage increase or decrease to a value (200 + 15% = 230). Handy for discounts, tips and tax, growth and KPI deltas, progress bars, dashboards and quick spreadsheet-style sums — without writing a formula. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 5 endpoints. A focused calculator, distinct from a general math-expression engine.

api.oanor.com/percentage-api

Convert and normalize plane angles. The convert endpoint moves a value between degrees, radians, gradians (gons), turns/revolutions, arcminutes, arcseconds, milliradians and DMS (degrees-minutes-seconds) — parse a DMS string like 12°34'56" or format a decimal angle as DMS. The normalize endpoint wraps any angle into the 0–360° or the −180–180° range. Perfect for graphics and game maths, CAD and surveying, robotics, astronomy and navigation headings. This covers plane angles specifically — a category general unit converters leave out. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. Distinct from general unit conversion and from geographic-coordinate conversion.

api.oanor.com/angle-api

Ejecuta estadísticas en una lista de números sin necesidad de una hoja de cálculo o un paquete estadístico. El endpoint describe devuelve un resumen completo de un conjunto de datos: recuento, suma, mínimo, máximo, rango, media, mediana, moda, primer y tercer cuartil y rango intercuartílico, varianza y desviación estándar poblacional y muestral, coeficiente de variación, medias geométrica y armónica, asimetría y curtosis. Obtén cualquier percentil de un conjunto de datos, el coeficiente de correlación de Pearson (y r²) entre dos series de igual longitud, y una regresión lineal simple (pendiente, intersección, r² y la ecuación de la recta). La entrada es un arreglo de números en bruto (JSON o una lista separada por comas) — sin CSV, sin encabezados. Perfecto para análisis, resúmenes de pruebas A/B, datos de sensores y métricas, paneles de control y análisis exploratorio rápido. Cálculo puramente local — sin clave, sin servicio de terceros, instantáneo. En vivo, nada se almacena. 5 endpoints. Distinto del motor de expresiones mathjs y de los resúmenes por columna de CSV.

api.oanor.com/stats-api

Berechnen Sie die Geometrie gängiger Formen. Ermitteln Sie die Fläche von 2D-Formen (Kreis, Quadrat, Rechteck, Dreieck – nach Basis/Höhe oder drei Seiten via Heron, Trapez, Parallelogramm, Raute, Ellipse, regelmäßiges Polygon), den Umfang oder den Kreisumfang, und für 3D-Formen das Volumen und die Oberfläche (Kugel, Würfel, Quader, Zylinder, Kegel, quadratische Pyramide). Übergeben Sie eine Form und ihre Maße und erhalten Sie das exakte Ergebnis sowie die verwendete Formel. Reine lokale Mathematik – kein Schlüssel, kein Drittanbieterdienst, sofort und deterministisch. Live. 6 Endpunkte. Entwickelt für CAD- und Engineering-Tools, Bildung und E-Learning, Bauwesen und Materialschätzung sowie jede App, die zuverlässige Formelberechnungen benötigt. Abgrenzung zu einem generischen Ausdrucksrechner oder Einheitenumrechner.

api.oanor.com/geometry-api

Convert integers between any numeral systems with exact big-integer math. Pass a number and a from/to base (radix 2 to 36, arbitrarily large, signed) and the convert endpoint returns the result and the decimal value; common 0x, 0b and 0o prefixes are accepted when they match the base, and whitespace or underscores in the input are ignored. The bases endpoint shows a single number across binary, octal, decimal, hexadecimal, base32 and base36 at once, together with its bit length, byte length and sign. Everything is computed locally with BigInt, so values of any size are exact and deterministic. Ideal for low-level and embedded debugging, networking and bit-twiddling work, teaching number systems, and anywhere you juggle hex, binary and decimal. A numeral-base converter — distinct from the text-encoding toolkit (encoding: base64/base32/hex of bytes), the Elixir/Erlang Hex package registry (hex) and number-to-words (numberwords). No upstream key, no cache.

api.oanor.com/baseconvert-api

Un motor matemático completo como API, impulsado por mathjs. Evalúa cualquier expresión — aritmética, cientos de funciones (sqrt, sin, log, gcd, factorial, combinaciones, …), constantes (pi, e), números complejos, matrices y teoría de números — con control de precisión opcional (por ejemplo, 2+3*sqrt(16) → 14, pi con 5 dígitos → 3.1416). Toma la derivada simbólica de una expresión con respecto a una variable (x^2+3x → 2*x+3), y simplifica álgebra (2x+3x → 5*x). Sin bibliotecas de fórmulas que empaquetar, sin matemáticas que reimplementar: envía una expresión, obtén la respuesta. Ideal para calculadoras y aplicaciones educativas STEM, lógica de hojas de cálculo y formularios, herramientas de cuestionarios y tareas, paneles de ingeniería y datos, y cualquier producto que necesite cómputo confiable del lado del servidor.

api.oanor.com/math-api