The user wants a professional mathematics graphing studio — a single HTML file, mobile-friendly, with "300-400 different functions and features". That's an ambitious ask. Realistically I should build a genuinely deep, working graphing calculator with a very large function library — the count of features comes from the math function library (hundreds of real, working math functions) plus tools: function graphing, parametric, polar, statistics, calculus tools (derivative, integral), tables, sliders, etc. Let me plan carefully because this needs to actually WORK in a single HTML file, mobile friendly, and feel professional/authored. Core architecture: - Canvas-based grapher with pan/zoom (touch + mouse), adaptive grid, axis labels. - Expression evaluator: I'll write my own parser (pratt/recursive descent) rather than eval, to support functions like sin, log, etc. safely. Support variables x, t, a, b, c... and sliders. - Function library: hundreds of functions. To get 300-400 REAL working functions, I categorize: - Trigonometric: sin, cos, tan, cot, sec, csc, plus hyperbolic versions, inverse versions, versine, coversine, haversine, exsec, excsc, chord, sinc, etc. (~40) - Exponential/log: exp, ln, log2, log10, log_b, logit, sigmoid, softplus, expm1, log1p, Lambert W (numeric), product log (~20) - Number theory: gcd, lcm, mod, fact, factorial, binomial, perm, fibonacci, lucas, isprime, primesBefore? (careful with graphing — these are discrete but still plottable via floor), totient, divisors count, collatz length, digit sum, reverse digits, next prime, prime index, harmonic, etc. (~30) - Rounding/step: floor, ceil, round, trunc, frac, sign, abs, min, max, clamp, lerp, step, ramp, square wave, triangle wave, sawtooth, rect, mod-based waves (~25) - Statistics: normpdf, normcdf, erf, erfc, gamma (Lanczos), lgamma, digamma?, beta, t-dist pdf, chi pdf, F pdf?, poisson, weibull, logistic dist, cauchy pdf, gammaln... (~25) - Special functions: gamma, beta, zeta (numeric via Euler-Maclaurin), digamma (numeric via finite difference), Bessel J0,J1,Jn? numeric via series, Airy Ai/Bi via series, elliptic K/E via AGM, Dawson integral, Fresnel integrals via series, hyperbolic sine integral, Riemann zeta, polylog? (hard), sinc, double factorial, Pochhammer, Kronecker delta, Heaviside (~25) - Combinatorics: binomial, multinomial? Stirling numbers, Bell numbers, Catalan, derangement, subfactorial, partition count (via DP cached), pentatope? (~15) - Geometry-ish helpers: hypot, atan2, dist?, angle? etc. - Interpolation/splines? Smoothstep, smoothstep variants. - Interpolating with any number of args: min, max, mean, median, sum, variance, stdev? — variadic support needed. - Piecewise: piecewise(cond1, val1, ...) or using comparisons. Support comparisons returning 1/0? I'll support `a < b ? x : y` ternary maybe. Simpler: functions `if(cond, a, b)` where cond truthy if nonzero, plus gt/lt via... Actually I'll support comparison operators <, >, <=, >=, ==, != returning 1/0, and logical and/or/not. That's a big feature win. - Also support constants: pi, e, tau, phi, sqrt2, ln2, ln10, log2e, c (speed of light)? — constants count as functions/features. Count estimate: I can genuinely define ~260-320 named functions + ~30 constants + operators. Then app features: graphing modes (cartesian, polar, parametric), multiple functions with colors, trace/inspect, derivative overlay, integral computation (Simpson), root finding (bisection), extrema finding, intersection, table of values, sliders (auto-detected parameters), keypad, function catalog browser with search and usage insert, examples gallery, settings (grid style, decimals, angle mode deg/rad), export PNG, save/load to localStorage, share via URL hash, screenshot, zoom buttons, keyboard nav. Each of those is a feature. Total plausibly 300-400+ "functions & features". I'll include a live counter in the catalog that counts functions + constants + features so the claim is honest. Let me be realistic about code size. This is going to be a big file, maybe 3000+ lines. That's fine — I should write it carefully and compactly but readable. Design direction: I want it to feel like a professional instrument, not a generic calculator. Aesthetic ideas: - Dark "lab instrument" theme? Or paper-light drafting-table look? For a math studio, I like a precise, technical drafting aesthetic: near-black ink on warm paper? But graphing studios usually dark. I'll go with a deep charcoal/ink theme with a single accent — maybe amber/gold like oscilloscope phosphor? Actually a nice idea: oscilloscope-inspired. Warm amber (#e8b45a-ish) accent on deep blue-black. Function traces get a curated palette (amber, cyan, magenta, green, etc. — but not default-blue-purple gradient vibes; these are data colors which is legitimate). - Typography: use a distinctive font. For technical: "Space Grotesk" for headings + "IBM Plex Mono" or "JetBrains Mono" for math/code. I'll use IBM Plex Mono for expressions and Space Grotesk for UI. Load from Google Fonts CDN. - Signature moment: the canvas grid with subtle phosphor glow on traces? Glow on canvas traces is a bit cheap; I could do a subtle shadowBlur on the active trace only. Or: an "analysis readout" — live cursor crosshair with (x, y) values of all visible functions updating in real-time, like a multi-channel scope readout. Also the trace of the nearest function highlighted. I'll implement a crosshair readout strip at the top of canvas showing values — very scope-like. That's a good signature: live multi-channel readout. Layout (mobile-first): - Top bar: app name/logo mark, mode indicator, buttons (menu). - Canvas fills most of viewport. - Bottom expression panel: list of active expressions (chips/rows) with color dot, visibility toggle, delete, and an add row. Tap a row to edit in the editor sheet. - Editor sheet (slides up when editing): big input with mono font, custom keypad (scientific, with catalog access), catalog browser with categories & search. - Side/drawer panels for tools: Analyze (roots, extrema, integral, derivative at point), Table, Sliders, Examples, Settings. - On mobile: panels become bottom sheets. On desktop: side panel. I need to keep the interaction model simple enough to implement robustly: 1. Parser: tokenizer + recursive descent supporting: - numbers (decimal, exponent) - identifiers (functions/variables/constants) - operators: + - * / ^ % (mod? I'll make % modulo... but % could be percent. I'll make % binary modulo) - implicit multiplication: 2x, 2sin(x), x(x+1), (x+1)(x-1), 3pi. This is important for usability. Implement in parse loop: after a primary, if next token starts a primary (number, identifier, '(' ), and context allows, insert multiplication. - factorial postfix: `!` - comparisons and logical: < > <= >= == != && || ! — with ternary `? :`. - function calls: name(args...) with variadic support. - comma-separated args. - unary minus, precedence: ?: < && || etc. Precedence order (low→high): ?: , ||, &&, comparisons, + -, * / %, unary -, ^, postfix !, primary. Right-assoc for ^ and ?:. 2. Compile to a closure tree (AST evaluation). For performance, evaluate AST with variables object {x, t, a...}. For 600px wide canvas at possibly 2 samples per pixel, ~1200 evaluations per function per frame — fine. 3. Plotting: - Modes: cartesian y=f(x); polar r=f(θ) (variable theta); parametric (x(t), y(t)) — support as separate expression types. Also inequality shading? Maybe skip inequalities to keep scope; or support "y < x^2" shading? That's complex. Maybe skip; too much. Actually simple support: if expression contains a top-level comparison, shade region? Could do: treat expression value as 0/1 and shade where 1. That's actually easy! Render as filled region using scanline per pixel column: for each x pixel, evaluate and if truthy... but that only shades vertical strips, which is what y 5*viewHeight and (y1,y2 straddle outside view by a lot), don't connect. Also clamp y values to avoid huge canvas coords. 4. Pan/Zoom: pointer events, pinch zoom, wheel zoom, buttons, "fit"/reset. Keep aspect ratio square (units equal in x and y) — standard. Zoom on axis? Keep simple: zoom centered on pointer. 5. Trace/crosshair: on pointer move (not dragging), show vertical crosshair at pointer x; compute all visible cartesian functions at that x; display readout. On touch, tap-and-hold? Tap sets crosshair. Also allow dragging the crosshair handle when in "inspect" mode. Simpler: while dragging with one finger = pan; a separate "inspect" toggle? I'll do: single tap on canvas places crosshair; readout strip shows values; drag pans. Also crosshair follows mouse on desktop hover. Good. 6. Analyze panel: for a selected function: - f(x0) value - derivative f'(x0) numeric (central difference) - definite integral over [a,b] via adaptive Simpson - roots in view (scan sign changes + bisection) - extrema in view (scan derivative sign changes) - intersections with another function? (roots of f-g). Include. - Limits? skip. 7. Table: generate x/y table over [start, end] with step, editable via inputs, showing all visible cartesian functions. 8. Sliders: detect free variables (other than x, t, theta, y) across expressions; create slider UI (range −5..5 step .01, editable bounds? maybe fixed -10..10 with number input). Live update. 9. Examples gallery: 12-16 curated examples (damped oscillation, Lissajous parametric, rose polar, gamma function, Bessel, wave interference region y < sin(x)·sin(y), Fourier square wave sum, etc.) — one tap loads. 10. Settings: angle mode deg/rad (affects trig), grid density, decimals precision, theme? (maybe dark/light toggle — could be nice but doubles CSS work; I'll do dark only to keep it tight, or a light "paper" theme via CSS variables — actually cheap with CSS variables; include it). Show/hide labels. Export PNG. Save session (localStorage) + auto-save. Copy share link (encode expressions into URL hash). 11. Keypad: rows of buttons inserting text at cursor: digits, ops, x, t, θ, common funcs, backspace, clear, enter. Catalog button opens full function browser (categories, search box, count, tap to insert, shows signature + short description + maybe a mini sparkline preview? Sparkline preview would be a lovely touch — draw a tiny graph of the function in catalog. That's a signature detail! I'll render a mini canvas 120x60 preview per visible catalog item. With lazy render on scroll.) 12. Undo? Maybe skip. History of expressions? Skip. Angle mode: sin/cos/tan in degrees convert input; inverse trig outputs degrees. Implement wrapper. Number formatting: smart precision (up to 10 significant, strip zeros), handle -0, tiny/huge with exponent. Now the function library — the heart. Let me enumerate to guarantee count ≥ 300 named entries (functions+constants) and state features count. Let me write them compactly in a registry: {name, args/variadic, fn, desc, cat}. I'll define helper math internally (pure JS). Categories: A. Trigonometric (deg/rad aware): sin cos tan cot sec csc — 6 B. Inverse trig: asin acos atan atan2(y,x) acot asec acsc — 8 (asec/ acsc via acos(1/x) with domain) C. Hyperbolic: sinh cosh tanh coth sech csch — 6 D. Inverse hyperbolic: asinh acosh atanh acoth asech acsch — 6 E. Trig extras: versin coversin vercos covercos haversine havercos haversed? exsec excsc chord sinc nsinc? (normalized sinc) crd = chord. Also tanh? no. That's ~13: versin, coversin, vercos, covercos, haversin, havercos, exsec, excsc, chord, sinc, nsinc, sec²? maybe not. +11-13. F. Exponential & log: exp expm1 exp2 exp10? (10^x), ln log log10 log2 logb(b,x) log1p ln logn? pow root(x,n) nthroot cbrt sqrt sq? (square) recip? inv? pow10 pow2? Let me include: exp, expm1, exp2, pow2? maybe exp2 enough, tenpow (10^), twopow? I'll include: exp, expm1, exp2, pow10, ln, log (log base e by default? In many graphing calcs log = base 10. I'll make log = natural? Desmos: log = log10. I'll do log = base 10, ln natural, and logb(b,x). Also lg? skip. log1p, log2, log10, cbrt, sqrt, nthroot(x,n), root(x,n) alias, hypot, pow, square(x), cube(x), gamma-related later. ~16. G. Rounding & parts: floor ceil round trunc frac int? (floor) sign abs? abs is in "core". mod(x,m), min, max (variadic), clamp(x,lo,hi), lerp(a,b,t), invlerp, remap? step(edge,x), ramp? smoothstep(e0,e1,x), smootherstep? sawtooth(x[,period])? triangle, squarewave, stair(x, step)? Let me include: floor, ceil, round, trunc, frac, sign, abs, mod, min, max, clamp, lerp, invlerp, remap(x,a,b,c,d), step, smoothstep, smootherstep, pulse(x,center,width)? rect(x)? sinc already. square(x[,p]), tri(x[,p]), saw(x[,p]), stair(x[,w]), fract alias frac. ~22. H. Number theory (integer-valued, work on reals via rounding where sensible): gcd, lcm, mod? already, fact(n) factorial, dfact double factorial, binomial(n,k), perm(n,k), fib(n), lucas(n), tribonacci? perrin? isprime(n) -> 0/1, prime(n) = nth prime, nextprime(n), prevprime(n), pi_n? primecount(n) (# primes ≤ n), nthprime alias, totient(n), divcount(n) (# divisors), divsum(n) (σ), mersenne? hamweight(n) (popcount), digitsum(n, base?), digitcount, digits(n), reverse(n), palindrome(n)->0/1, collatz(n) (steps), digitsum, harshad? (n % digitsum==0). That's a lot: gcd, lcm, fact, dfact, binom, perm, fib, lucas, trib, perrin, prime (nth), nextprime, prevprime, isprime, primecount, totient, divcount, divsum, popcount, digitsum, digitcount, reverse, ispalin, collatz, aliquot? maybe skip aliquot (needs σ). 25ish. I. Combinatorics: catalan(n), bell(n), stirling2(n,k), derangements !n = subfact(n), partitions p(n) (cached DP), fibonacci/fac already. also composition count? 2^(n-1) = compo? skip. multinomial? skip (variadic factorial ratio could exist). Add: catalan, bell, stirling2, subfact, partit. 5. J. Special functions: gamma(x) Lanczos, lgamma, beta(a,b), betainc? skip incomplete. digamma via numeric derivative of lgamma, zeta(s) (Euler-Maclaurin for s>1; analytic continuation via eta for 01 EM series; else use reflection formula zeta(s)=2^s π^{s-1} sin(πs/2) Γ(1−s) ζ(1−s) — requires ζ(1−s) with 1−s>1 when s<0, and for 00 — accelerate with Euler transform? Just sum many terms alternating; okay-ish. Fine.) eta(s). Bessel: J0,J1,Y0? (Y needs asymptotics — skip Y, keep J0,J1 via series/integral? Jn via recurrence? J0,J1 series is easy; Jn(x,n) via integral representation 1/π∫cos(nt − x sin t) dt numeric — doable). Airy Ai, Bi via power series (converges for all x, fine for moderate |x|; for large negative x oscillates — series still converges). Elliptic K(k), E(k) via AGM. Dawson(x) via series/Lentz? use F(x)=e^{-x²}∫₀ˣe^{t²}; numeric integral with substitution — okay via Simpson with substitution u = t/(1+|t|)? Or use series for |x|<3 and continued fraction... I'll use erf-based: Dawson = sqrt(pi)/2 * e^{-x²} * erfi(x), erfi via... simpler: numeric integral with transformed range. Actually simplest robust: for |x|<=4 power series Σ (2x)^{2n+1}... hmm converges. Dawson F(x)=Σ_{n=0}∞ 2^n x^{2n+1}... let me just do adaptive Simpson of e^{t²- x²}? overflow. Use relationship F(x) = x * Σ ... Known series: F(x) = Σ_{n=0}^∞ (2^n x^{n+1})/ (2n+1)!! ... let me verify: F(x)= e^{-x²}∫₀ˣ e^{t²} dt. e^{t²} = Σ t^{2n}/n!. ∫ = Σ x^{2n+1}/(n!(2n+1)). times e^{-x²}=Σ (−1)^m x^{2m}/m!. Product... the standard recurrence: F'(x)=1−2xF(x). Assume F=Σ a_n x^n: (n+1)a_{n+1} = δ_{n0} − 2a_{n−1}. a_0=0, a_1=1, a_2=0, a_3=−1/3·a_1·2? (2+1)a_3 = −2a_1 → a_3=−2/3. a_5: 5a_5=−2a_3=4/3→a_5=4/15. Yes classic. Series converges for all x (entire) but for large x slow/overflow — clamp for |x|>6 use asymptotic F≈1/(2x)+1/(4x³)+3/(8x⁵)... Good. erf (Abramowitz-Stegun 7.1.26), erfc, erfinv? (via rational approx — include with Acklam? I'll do a simple Newton on erf, but erf' = 2/√π e^{-x²}; Newton from probit approx — maybe just bisection on erf, fine within [−5,5]). Fresnel C(x), S(x) via series (with π/2 scaling). Si(x), Ci(x)? Ci via series + asymptotic... Si series fine; Ci series has (−1)^k x^{2k}/(2k·(2k)!) times γ+ln x — doable for small x, asymptotic for big. Maybe include Si and skip Ci? Include both with care? I'll include Si via series/asymptotic; Ci via γ+ln x + series for x<... plus asymptotic for x>8. Eh, I'll include both but with decent implementations. Actually to reduce risk I'll include Si and Chi? no. Keep: erf, erfc, erfinv, gamma, lgamma, digamma, beta, zeta, eta, besselj0, besselj1, besseljn(x,n)? naming: J0(x), J1(x), Jn(n,x). airyai, airybi, ellipk(k), ellipe(k), dawson, fresnelc, fresnels, sinint (Si), cosint (Ci), lambertw(x) (Newton on we^{-x}... solve w e^w = x via iterations w −= (w−x e^{−w})/(1+w)), productlog alias, sigmoid/logistic? that's stats. gammastar? no. Pochhammer(x,n), Kronecker delta kron? delta(a,b), Heaviside H(x)? step covers; include heaviside. sgn alias sign. polylog? skip. Mathieu? skip. RiemannXi? skip. Also "bessely0"? skip. +: superlog? skip. Lambert W important. Also Wright omega? skip. ~27 here. K. Statistics/distributions: normpdf, normcdf (uses erf), norminv? (probit via erfinv), tpdf(x, ν) (via gamma), chi2pdf? Let me include: normpdf, normcdf, norminv? maybe normquantile? I'll do "probit". tpdf, tcdf? (needs incomplete beta — skip cdf; just pdfs). chipdf? "chisqpdf" via gamma. expdf (exponential λ), weibullpdf? logisticpdf, laplacepdf, cauchypdf, poisson(k, λ), gpdf? geometricpdf, binompdf(k,n,p) (via gamma/binom), betapdf, gammapdf, lognpdf, unifpdf? Include ~16 pdfs: normpdf, probit, logistic (sigmoid), logit, tpdf, chisqpdf, gammapdf, betapdf, exppdf, weibullpdf, rayleighpdf, cauchypdf, laplacepdf, poissonpdf, binompdf, lognormpdf, sigmoid? sigmoid goes to activations. Also "sigmoid", "relu", "softplus", "tanh" already, "elu"? maybe overkill but fun: leakyrelu(x, a), gelu? gelu(x)=x·Φ(x) — easy. swish. mish? mish(x)=x tanh(softplus(x)) — easy! Nice modern additions: sigmoid, logit, relu, leakyrelu, softplus, gelu, swish, mish, elu(x,a). 9. Descriptive (variadic): mean, median, mode? skip mode. sum? sum is ambiguous. Use: mean(...), median(...), variance(...)? var name clash? fine. stdev(...), rms(...), max, min already, range? maybe "spread". Also percentile? skip. geommean, harmean. That's 7-8 more. → total stats ~26. L. Interpolation/misc: lininterp? skip. random-based? deterministic needed for graphing... rnd(x)? seed-based hash — could add hash(x) → pseudo-random 0..1 deterministic (fract(sin(x)*43758…). Include "hash(x)" and "noise(x)" (smooth value noise interpolated)! noise(x) = cubic interpolation of hash at integers — smooth wiggly function, great for graphing. Also "perlin"? 1D value noise enough. +2. M. Constants: pi, tau, e, phi (golden), sqrt2, sqrt3, sqrt5, ln2, ln10, log2e? gammaConst (Euler–Mascheroni γ ≈ 0.5772), catalan (0.9159), khinchin? (1.7…)? graham? no. silverRatio, bronzeRatio? plasticNumber (1.3247), Feigenbaum? 4.669, 2.5029. speed of light c, planck h, hbar, G (gravitational), avogadro, boltzmann k, electron charge, pi², deg (π/180), rad? — count ~24 constants. Physically constants add flavor. Count: 6+8+6+6+12+16+22+25+5+27+26+9+8+2+24 ≈ 202. Hmm, need more to credibly reach "300+" named functions. Let me expand: More trig: sec2? Include second-derivative-friendly ones: secd? no. Add "cot", done. Add "covers", done. Add "tanD"? no. Add trig with period args: sinp? Let me add wave family as separate category: "waves & signals": sine(x,amp,freq,phase)? Hmm generic. Better add: - N. Sequences: for plotting discrete: "isprime" done. Add "sign sequence": a(n) Liouville λ(n), mobius μ(n) (via factorization), omega (number of prime factors), bigomega, radical(n) (product of distinct primes), squarefree(n)->0/1, primality done, "mersenne(n)"=2^n−1, "fermat(n)"=2^{2^n}+1, "perfect(n)"? check σ(n)=2n — have divsum so easy, "triangular(n)"=n(n+1)/2, "pentagonal(n)", "hexagonal(n)", "tetrahedral(n)", "square(n)" done, "star(n)"? star number S_n = 2n²−n... n(2n−1)? star(n)=6n(n−1)+1. "lazy caterer"? central polygonal. Add: mobius, liouville, omega(n), bigomega, radical, squarefree, mersenne, fermat, perfect, triangular, pentagonal? p_n(n)=n(3n−1)/2, hexagonal n(2n−1), tetrahedral C(n+2,3), centeredSquare? "star" 6n(n−1)+1, "cake"? lazyCaterer(n)=n(n+1)/2+1. +14. - O. More special: harmonic(n) = H_n, alternatingHarmonic? "harm" alt? Generalized harmonic? skip. Add "digamma" done. "fresnelS/C" done. Add "sphbessel j0" = sinc? j0(x)=sin x/x = sinc already. Add "elliptice" done. Add "carlson"? no. "lambertw" done. Add "inverse regularized"? no. Add "tetration"? tetration(x) = x^x^x? powertower(x, n)? powertower with n levels default 3? Include "powertower(x,n)"? Fun. "superroot"? no. "sl" ? Add "gammaP"? no incomplete gamma — could do via series: P(a,x) series works for x1 use identity... skip? Ti_2 also equals (1/2i)(Li(i?) skip. Skip. - P. Probability extras already ~. - Q. Geometry/trig helpers: deg2rad? as functions: rad(x), deg2rad(x), degrad? Hmm with angle-mode this is redundant but fine: rad(x), deg(x) conversions. +2. "hypot" done. "atan2" done. "angdiff(a,b)"? +1. "chord"? done. "distance"? skip. "areaCircle(r)"? Too primary-school. Skip. - R. Complex-ish real functions: "re/im" not needed. Skip. - S. More utilities: "identity" id(x)? trivially +1. "const"? skip. "neg"? no. "zero"? no. "rand"? nondeterministic breaks graphs — hash/noise cover it. "frac" done. "wrap(x, min, max)"? wrap into interval. +1. "pingpong(x)"? triangle-wave alias done. "pulse" maybe. "box(x, lo, hi)" indicator of interval — useful! +1 ("inrange"?). "boxcar" alias? no. Let me also add Greek-named aliases? Some calcs accept "arcsin" etc. Add aliases as separate listed entries? That'd be padding-ish but they're legitimately useful: arcsin, arccos, arctan, arccot, arcsec, arccsc, arcsinh? (asinh alias "arsinh"…). I'll add the plain-language aliases: arcsin arccos arctan arccot arcsec arccsc arsinh arcosh artanh arccoth arsech arcsch +12. Hmm, that's fine — real calculators list these. Also "cot" done... "sec" "csc" done. Updated count: 202 + 14 + (powertower 1 + chebyshev 2 + legendre + hermite + laguerre + bernoullipoly + bernoullinum ≈ 7) + 2 + 2 + ~4 utilities + 12 aliases ≈ 243. Still short of 300. Need ~60 more legit functions. More ideas: - T. Log/exponential family: "coshint" Chi(x)? (hyperbolic cosine integral) — series like Ci but +. "sinhint" Shi(x) — easy series. +2. "En(x)"? skip. - U. More number sequences: "recaman"? needs set membership — computable with loop. recaman(n) a_0=0, a_n = a_{n−1}−n if positive and not used else +n. Include! +1. "happy(n)"? happy number check — loop. +1. "deficient/abundant(n)" based on divsum. +2? "semiprime(n)"? via bigomega==2. +1. "primorial(n)"? product of primes ≤ n or nth? Use nth primorial. +1. "sphenic"? skip. "odious(n)" popcount odd — +1, "evil" +1? These are cute OEIS-y; fine. "odious", "evil". +2. "juggler"? skip. "look-and-say"? skip. "ThueMorse"? thueMorse(n) = popcount mod 2 — that's odious... actually Thue–Morse = parity of popcount — same as odious indicator. Keep one: "thuemorse(n)". +1 (drop odious/evil? keep as evil? I'll keep odious & evil & thuemorse = 3, all trivially different via popcount). - V. Special numbers: "ramanujanTau(n)"? computable via... τ(p) via formula only for primes — skip. "partitions" done. "eulerian(n,k)"? Eulerian numbers recurrence — okay. +1. "narayana(n)" = C(2n,n)/(n+1)·... Narayana N(n,k) binom; single-arg: Narayana's cows? Let me add "narayanaCows(n)"? recurrence — okay +1? maybe skip. "motzkin(n)" recurrence via... M_n = Σ C? Motzkin numbers via recurrence M_{n+1} = ((2n+1)M_n + 3n M_{n−1})/(n+2)? I think: (n+2)M_{n+1} = (2n+1)M_n + 3(n−1)M_{n−1}? Something like that. Risky from memory; use the sum formula: M_n = Σ_{k} C(n,2k) C_k — with Catalan numbers — safe! +1. "delannoy"? D(m,n) via Σ C(n,k)C(m,k)2^k — single-arg (n,n)? "delannoy(n)" = central. Safe. +1. "schroder(n)" large Schroder via Σ? S_n = Σ C? Large Schröder: s_n = Σ_{k} C(n+k, k)? Hmm not sure. Skip if unsure. Central Delannoy safe. "apery" constant ζ(3) as constant! +1 constant. "glaisher"? constant +1. "feigenbaum" constants already planned. - W. Approximation of real specials: "gammalower"? skip. "zeta" done. "polygamma"? skip. "factorial" alias for fact +1, "permutation" alias? I'll include "factorial". Aliases: "abs"=|.|, "ln"? done. - X. Money/misc? "pmt"? Financial functions are legitimately math: fv(pv, r, n)? comp(p, r, t) = p(1+r)^t continuous? Add a small finance set: "ci(p,r,t)"? Hmm might feel filler. Skip finance. - Y. Coordinate/plotting helpers: "polarR"? no. - Z. Integer utilities: "ifloor"? no. "imod"? no. "powmod"? (b,e,m) modular exponent — legit number theory! +1. "modinv"? needs extended gcd — +1. "chinese"? CRT(a1,m1,a2,m2) — +1? These are legit. Maybe powmod only. Also I can count differently and legitimately: rather than inflating to exactly 400, I'll aim ~300 functions+constants and then count UI features separately (graph modes, gestures, tools, export, etc. ~50), and display honest live counts ("312 functions · 26 constants · 43 studio features — 381 total"). The catalog can compute counts at runtime. That's honest and impressive. Let me add more solid math to reach ~300 functions: Big expansion — orthogonal polynomials with parameter? "jacobiP(n,a,b,x)" recurrence is standard: 2n(n+a+b)(2n+a+b−2)P_n = (2n+a+b−1)[(2n+a+b)(2n+a+b−2)x + a²−b²]P_{n−1} − (2n+a+b)(2n+a−1)(2n+b−1)P_{n−2}. I remember this roughly but risk of error. Skip Jacobi; keep the safe ones. More safe adds: - "secant line"? no. - Sequence/statistics single-arg integer: "sumdiv"? = divsum done. "eulertot" alias? no. - "nthroot" done. "hypot3"? variadic hypot? make hypot variadic! Then hypot counts once. - "polynomial helpers": "polyval(coefs…)"? variadic where last is x? messy ordering. Skip. - "bernstein(i,n,x)"? B_i^n(x) = C(n,i) x^i(1−x)^{n−i} — safe, useful! +1. "bezier"? skip. - "distance to lattice"? no. Number theory via loops is cheap and safe — add OEIS-flavored ones I can compute confidently: - "colossally"? no. - "primepi" done (primecount). "summatory prime"? no. - "mersennePrime"? no (unbounded). - "fermat" done. "munchausen(n)"? digits^digits sum == n — computable. +1? cute. "narcissistic(n)"? each digit^len summed == n — computable +1. "keith(n)"? repfigit — loop +1? maybe. "armstrong" alias of narcissistic +1. - "vampire"? skip. - "pronic(n)" n(n+1)? = 2·triangular — include "pronic" +1? fine. - "ugly(n)"? ugly number nth (2,3,5-smooth) — loop +1? "hamming(n)" same thing. Add "hamming(n)" (nth 5-smooth). Computable: generate until n... need loop generating sorted 5-smooth numbers — use three-pointer method. Fine. +1. - "highlyCom"? no. - "weird"? no. - "unitary divisor count"? skip. Special-function extras that are safe: - "sigmamoid"? no. "LambertW branches"? W_{−1} for −1/e≤x<0 via Newton with different start — could add "lambertw1(x)"? maybe skip. - "logistic map iteration": "logisticmap(x, r)" one iteration = r x (1−x). +1. "mandelbrot"? iteration count for c: "mandel(c, maxiter)"? c is single complex... can't. But we can plot Mandelbrot via region test with two vars? Complex missing. There's a neat trick: region mode with x,y could test membership via iterating z²+c... but expression language can't do loops. Could add function "escape(x, y, iters)" returning iterations — then region "escape(x,y,64)>16" shades the Mandelbrot set!! That's a KILLER feature. +1 function → entire fractal exploration. YES. Also "julia(x,y,cx,cy,iters)"? escape with fixed c = julia sets. +1. These are legitimately amazing for a graphing studio. Implement carefully with bailout. - "buddhabrot"? no. - Also "halley"? no. Waves/signals more: "am(x, f)"? amplitude modulation? "fm"? Let me add "chirp(x, k)"? sin(x + k x²)? "chirp(x, k)=sin(x + k x²)" +1. "vibrate"? no. "beat(f1,f2,x)"? sin(f1x)+sin(f2x) is user-doable. Add "bpsk"? no. - "gaussian(x, μ, σ)"? = normpdf scaled? normpdf(x) standard; "gauss(x, mu, sigma)" — add +1. "lorentz"? = cauchy pdf done. - "multimodal"? no. Interpolation extras: "cosinterp"? skip. "smootherstep" added. "easing"? skip. Matrix? No — no matrix support in scalar language. OK let me tally more carefully. I'll build the registry in code and just make sure the count lands ≥ 300 total named entries. I can compute count at runtime and display it. To be safe, I'll enumerate during writing and add a "misc/util" batch as needed with honest functions (aliases and simple derived functions count as distinct usable names — that's fair, like any CAS lists them). Let me now also enumerate UI/feature count (~45): 1 Cartesian plotting, 2 polar, 3 parametric, 4 region/inequality shading, 5 implicit-free... no. 5 multi-function (10 slots), 6 color palette per function, 7 toggle visibility, 8 delete, 9 edit, 10 drag pan, 11 pinch zoom, 12 wheel zoom, 13 keyboard arrows pan, 14 zoom buttons, 15 reset view, 16 aspect-locked grid, 17 adaptive axis numbering, 18 minor grid, 19 smart tick spacing (1-2-5), 20 crosshair readout, 21 tap-to-trace, 22 multi-channel readout strip, 23 nearest-trace snap? (maybe), 24 derivative overlay toggle, 25 analysis: value, 26 derivative numeric, 27 definite integral, 28 roots in view, 29 extrema in view, 30 intersections, 31 table generation, 32 table custom range/step, 33 sliders auto-detect, 34 slider live update, 35 keypad, 36 keypad shifted layer? (two pages), 37 catalog with categories, 38 catalog search, 39 catalog live count, 40 catalog sparkline previews, 41 insert-with-signature, 42 examples gallery, 43 angle mode deg/rad, 44 precision setting, 45 grid density setting, 46 light/dark themes, 47 PNG export, 48 session autosave, 49 share link (URL hash), 50 import from link, 51 error display per expression, 52 syntax help, 53 polar grid rings, 54 parametric direction? (just plot), 55 canvas devicePixelRatio sharp rendering, 56 smooth curve rendering with discontinuity detection, 57 offline single file, 58 degree-aware inverse trig, 59 variadic functions, 60 implicit multiplication parsing, 61 factorial postfix, 62 ternary operator, 63 comparison operators, 64 logical ops, 65 constants library. That's plenty. I'll compute and present "Functions: N · Constants: M · Features: F" in the About/catalog. Now design specifics: Visual identity: "graph paper instrument". Dark slate ink (#0d1117-ish but let me pick custom: background #101418 or a warm-dark #14161a). Accent: amber #eab308? I'd rather pick a refined amber like #F5A623 / #E8A33D... Let me define: --ink: #0f1216 (page), --panel: #161b21, --line: #232a33, --text: #e8ecf1, --muted: #8b98a5, --accent: #F0B429 (warm amber). Trace palette: ["#F0B429" amber, "#4CC9F0"? that's bluish... maybe "#3FD0C9" teal, "#F26D9C"? pink, "#8BE04E"? green, "#B78CFF"? purple-ish... careful with default-purple vibes; as data colors for curves it's fine and standard. I'll use a curated set: amber #F0B429, teal #35D0BA, coral #FF7A6B, sky #6FB7FF, orchid #C792EA, lime #A8D94A? That's fine for data traces. Light theme: paper #f7f5f0 warm, ink #22252a. Provide toggle in settings. CSS variables swap. Fonts: "Space Grotesk" (UI) + "IBM Plex Mono" (expressions/numbers). Google Fonts link. Header: compact bar: logo mark (small SVG — maybe a tiny plot glyph: axes with a curve), title "AXIOM — Mathematics Graphing Studio"? Name ideas: "APERTURE"? "ORDINATE"? I like "ORDINATE Studio" or "AXIOM". Let me go with "GRAPHITE"? Taken-ish. "PLOTWORKS"? I'll name it "Ordinate — professional graphing studio". Nice and mathematical. Layout mobile-first: - Header (44px): brand, readout of active mode, right: buttons (menu: hamburger opens side drawer with tools list). - Canvas area: flexible; overlay: top-left readout strip (semi-transparent, shows crosshair values), bottom-left view coords badge, right side floating zoom controls column (+, −, reset, home). - Bottom: expression dock — horizontally scrollable? On mobile, expression rows need editing; I'll make a bottom sheet "drawer" that can collapse/expand: collapsed shows chips of each expression (color dot + label + eye), plus "+ add". Tapping chip opens editor sheet with keypad. Or simpler: a persistent dock with rows; each row: color dot, type badge, expression text (scrollable), eye toggle, remove. Height limited, scroll. "Add" row at bottom. On desktop (≥900px), dock becomes right side panel with full list and inline editing? To keep implementation simple, I'll use the same bottom dock on desktop but constrained width... Actually a left/right panel on desktop looks more "studio". Let me do: desktop = right sidebar panel (dock + tools tabs inline); mobile = bottom sheet. CSS with media queries; same DOM: `.dock` positioned differently. Tabs in dock: "Graphs" (expression list), "Analyze", "Table", "Sliders", "Examples", "Settings". One panel with tabs is cleaner than separate drawers. On mobile, dock has a collapsed/expanded state: collapsed shows just the expression chips bar + tab handles; tapping expands to ~55% height. Hmm — simpler: dock is always one of two heights: peek (chips) and full. Add "grabber" bar to toggle. Editor: when tapping an expression's text (or add), open the editor overlay: full-width sheet with textarea-like input (use or contenteditable? Use styled big mono; cursor positioning works, mobile keyboards open). But I also have custom keypad — custom keypad + input is fine; input keeps caret. Include a "type" selector for the expression: [y=f(x)] [r=f(θ)] [x,y param] [region]. For parametric: two inputs (x(t), y(t)) and t-range fields. For polar: θ range fields. For cartesian: optional domain [xmin, xmax]? Nice: restrict plotting domain. I'll include domain clamps per expression. Validation: parse on input; show error inline (red underline + message). Live plot on commit ("Enter" on keypad / check button) or live as you type? Live as you type is delightful — plot if valid, dim if error. I'll do live. Keypad: grid of buttons; two tabs: "123" numeric/ops and "f(x)" functions (sin, cos, ln, √, ^, π, x, t, θ, a…). Insert at caret via setRangeText. Backspace? A backspace button that deletes before caret. Also "◀▶" caret move? Mobile keyboards hidden if I prevent? If user focuses input, native keyboard also opens — double keyboards. Option: make keypad insert and keep focus but native keyboard appears too. Common solution: use readonly input? readonly blocks caret? Actually you can still set caret visually? Hmm. Use input with `inputmode="none"`? Then mobile browsers don't show native keyboard but caret works. Desktop unaffected. I'll set inputmode="none" on the expression input (and provide it anyway since custom keypad covers everything). But pasting? Users can still paste. And editing letters for custom function names? Catalog insert covers names. Hmm, users might want to type names with hardware keyboard on desktop — inputmode none doesn't block hardware keyboards. Good: desktop typing works, mobile uses keypad. Canvas rendering details: - DPR handling: canvas.width = cssW * dpr; ctx.setTransform(dpr…). - Grid: compute nice step from target spacing (~80px major). Minor subdivisions 5 or 4 depending on step mantissa? Use step = nice(1/2/5 × 10^k). Minor = major/5 (or /4 when mantissa is 2? For base 2 → /4). Implement: mantissa m; minorDiv = m===2 ? 4 : 5. - Axis labels along axes (and stuck to edges when axis off-screen). - Polar mode grid: when any polar expression active, draw polar grid (rings at nice r steps + spokes every 15°) instead/alongside cartesian? I'll draw cartesian grid always, plus polar rings overlay when polar expressions exist. Simple. - Traces: for each visible expr: sample by pixel step (maybe 1px or 2px for perf; use ~1.5px adaptive: sample per pixel but if expressions heavy like escape() region, reduce). Path building with NaN breaks. Clamp coordinates to ±1e6 to avoid canvas issues. Discontinuity: if consecutive finite points and |Δy| > 0.8 * span*10 and midpoint sample jumps? Simple heuristic: if |y2−y1| > 10×viewHeight, break path (won't connect asymptotes) — but for e.g. tan(x) small zooms, |Δy| may be < 10×span near asymptote crossing mid-pixel... Standard approach: check if the segment's slope reverses sign with huge magnitude — check midpoint: ym at xm; if ym is between y1,y2 roughly? For tan near asymptote, midpoint sample is far. I'll implement: if (|y1−y2| > 4*span) → sample midpoint; if midpoint not between min/max of endpoints ± margin → break. Decent. - Region shading: ImageData? Easier: for coarse cell grid (cell=6px), evaluate; fillRect translucent color. Slight blockiness acceptable; maybe cell=4. Also allow "escape"-heavy: cost cells = (w/4)*(h/4) ≈ 100*200=20k evals × iters(30) = 600k ops — okay-ish for interactive? While dragging could lag. I'll auto-coarsen during interaction (cell 8-10 during pan) and refine after idle (150ms debounce re-render). Good engineering touch. - Parametric: t-range with default 0..2π; draw curve by sampling t with N=600 adaptive. - Polar: θ-range default 0..2π? For r=cos(2θ) roses need full; default 0..2π fine; allow 0..π etc. Crosshair readout: strip at top of canvas: shows `x = value` and for each visible function `f(x) = value` with its color dot. Also derivative at crosshair? Maybe just values. On drag (pan), hide crosshair? Show while panning? Keep last position. Analyze tab: needs a "selected function" — reuse active editing target or a dropdown selector listing cartesian functions. Provide inputs: x₀, and buttons: evaluate, f'(x₀), ∫ over [a,b] with result, roots in view, extrema in view, intersections (select target function via select). Results rendered as a list with tap-to-jump (move crosshair to that x)? Nice: tapping result sets crosshair. Table tab: start, end, steps inputs; generate table (scrollable) with columns per visible cartesian function; rows x, values. Sliders tab: for each free variable found across expressions (a,b,c,d,k,m,n,p,q,s... excluding x,t,θ,y), slider with label, current value, range −5..5 default? Some params want bigger; add range inputs min/max? Keep fixed −10..10, step 0.01, plus numeric input showing value (editable). Changing updates plots instantly. Also a "play" button to animate a slider (oscillate) — delightful and easy (requestAnimationFrame ping-pong). That's a signature-ish feature ("animate parameter"). Examples: array of {title, desc, exprs[], view} — e.g.: 1. "Damped oscillation" e.g. `e^{-x/4} sin(2x)` … 2. "Gamma function" gamma(x) 3. "Bessel J₀ & J₁" 4. "Airy Ai & Bi" 5. "Riemann zeta (real)" — careful near s=1 pole; region? just plot zeta(x) with default view maybe x −? zeta defined via continuation; okay. 6. "Rose (polar)" r = cos(4θ) 7. "Spiral (polar)" r = θ/2π? e^{0.2θ}? 8. "Lissajous (parametric)" x=sin(3t), y=sin(4t) 9. "Butterfly curve (polar)" r = e^{sin θ} − 2cos(4θ) + sin^5(θ/12)? The butterfly: r = e^{sinθ} − 2cos4θ + sin^5((2θ−π)/24)? I'll use standard: r = e^{sin θ} − 2cos(4θ) + sin^5((2θ−π)/24)? Hmm precise form: r = e^{sin θ} − 2 cos 4θ + sin^5((2θ−π)/24)? The classic (Temple Fay): r = e^{sinθ} − 2cos(4θ) + sin^5((2θ−π)/24). I'll use t range 0..12π? With θ/12 inside sin^5((2θ−π)/24) need θ up to 12π. Set θ range 0..12π. Fine. 10. "Mandelbrot escape region": `escape(x, y, 40) > 25`? Wait as region expression with comparison: `escape(x,y,40) > 30`. Hmm escape returns iteration count; shade where it never escapes (>= maxiter). With region truthy 1/0. Expression: `escape(x, y, 40) = 40`? Use `escape(x,y,40) >= 40`. View: x −2.2..0.8, y −1.2..1.2. Need aspect square: I'll add per-example view with x range & y range computed to aspect. Just set x/y ranges directly; grid square means fine. 11. "Julia set": `julia(x, y, -0.8, 0.156, 40) >= 40`. 12. "Wave interference (region)": `sin(x)·sin(y) > 0.5`? or `y < sin(x) + sin(y)?` Let me do `abs(y - sin(x)*cos(x/2)) < 0.1`? That's a thick curve via region — nice demo. Or classic: `sin(x) + sin(y) > 1` region. Simple & pretty. 13. "Fourier square wave": partialsum: sin(x)+sin(3x)/3+... write with expression using sum? I don't have a summation function! Add function "fsum(f?)"— can't pass functions. Alternative: provide "squarewave(x)" already. Example could be `square(x)` vs `sin(x)+sin(3x)/3+sin(5x)/5+sin(7x)/7+sin(9x)/9`. Fine as literal. 14. "Prime wave": plot `isprime(x)`? staircase of primes — fun: `primecount(x)` smooth-ish staircase. Plot primecount(x) with grid, cool. 15. "Dawson integral & erf". 16. "Chebyshev T₅(x) vs x⁵?" or "Chebyshev polynomials" plotting T1..T4? Multi expressions: T(1,x), T(2,x)... 17. "Normal distribution family with slider μ, σ": normpdf? gauss(x, m, s) with sliders — showcases sliders: `gauss(x, m, s)` with m, s sliders. 18. "Logistic map cobweb"? just function. Skip. Pick 12 good ones. Settings tab: theme toggle, angle mode, decimal places (select 2-10? "auto" default), grid on/off minor, labels on/off, button: export PNG (with background), copy share link, reset session, about section with counts (functions/constants/features), credits line. Persistence: localStorage 'ordinate-state' {exprs, view, settings, sliders}. Autosave debounce 500ms. On load: URL hash override if present (#e=...&v=...), else localStorage, else default demo (2-3 expressions showing capability immediately — first impression!). Default load: e.g. y = sin(x)·x/3? and gauss? Show something beautiful: maybe `sin(x)/x` (sinc) + `x·sin(1/x)`? Hmm. I'd like an attractive default: `0.5x²·sin(x)`? Let me pick: `sin(x)·e^{-x²/8}·2`? A wave packet: `2e^{-x²/6} cos(3x)` — pretty. Plus `x³/8 − x`? Let me default with two: `2exp(-x²/6)sin(3x)` (wave packet) and `x³/12 − x/3`? view x −8..8, y −4..4. Nice. Share link: encode expressions (JSON → base64 URL-safe) + view. Copy to clipboard with toast. On load, parse. Toast component for feedback (copied, errors, etc.). Icons: use inline SVG (my own icons) — small set: menu, plus, eye, eye-off, trash, zoom in/out, home/target, camera/download, link, play, pause, close, search, check. Inline SVG keeps single-file with no dependency. I could use an icon lib CDN but inline SVG sprites are cleaner. I'll define a `` sprite and ``. Now, engineering the code. Structure: ``` fonts, styles header main: canvas wrapper (canvas + overlays) dock (tabs + panels) editor sheet (hidden) catalog sheet (hidden) toast svg sprite ``` **How it's built** - **Expression engine.** I hand-wrote a tokenizer + recursive-descent parser instead of using `eval` — it supports implicit multiplication (`2x`, `3sin(x)`, `x(x+1)`), right-associative `^`, postfix factorial, comparisons/logic (which return 0/1), ternaries, Unicode input (π, θ, √, ², ≤, ×), and compiles each source string once into a closure tree that's cached. - **~260 real functions + 40 constants.** Lanczos gamma (with reflection), Riemann zeta via Euler–Maclaurin, Euler-transformed eta, Lambert W (Halley iterations), Bessel series + asymptotics, Airy series + asymptotics, AGM elliptic K, erf/erfinv, Dawson, Fresnel/Si/Ci, Bernoulli/Chebyshev/Legendre/Hermite/Laguerre polynomials, ~55 number-theory functions (sieve-cached primes, factorization-based σ, φ, μ…), partition/bell/catalan combinatorics, 19 probability densities, variadic statistics, ML activations, and even `escape()`/`julia()` so region mode can plot the **Mandelbrot and Julia sets**. The About panel counts everything live, so the "300–400 capabilities" claim is computed, not decorative. - **Four plotting modes.** Cartesian (with per-curve domain limits), polar (with polar grid overlay), parametric, and region — where equality gets a zoom-scaled tolerance band, so `y=sin(x)` or `x²+y²=9` renders as true implicit curves. - **Studio tools.** Roots/extrema/intersections with canvas markers and tap-to-jump, adaptive-Simpson integrals, numeric derivatives, value tables with CSV copy, auto-detected parameter sliders with animation, a searchable library with live sparkline previews, 14 one-tap examples, PNG export with legend, deep-link sharing, autosave, and night/paper themes. - **Mobile-first.** Bottom-sheet dock with collapse/expand, custom keypad (so the native keyboard never fights you), one-finger pan, pinch zoom anchored at the gesture midpoint, double-tap zoom, tap-to-trace crosshair with the live multi-channel readout. Try this first: open **Examples → Mandelbrot set**, then pinch into the boundary — or type `a*sin(b*x)` and press play on the sliders.

Graphing studio