2e:null 2f:["$","title",null,{"children":"ƒurl expression builder | ƒ | Observable"}] 34:T3254,// TODO no need for bigint in our term tuples... // should store atomics as 2-tuples with symbolic tag head // e.g. `Integer(123)` stored as `['Integer', 123]` // just need to roll a simpler immutable-tuple implementation, enforcing type: Tuple // this should simplify implementation, make it work everywhere, and reduce interning costs... // should leverage underlying structural sharing of string "ropes" in js engines? // also allows us to ditch the two-level node dance, and just have a single term node // can set up prototype however before freezing // still capable of memoize whatever is needed w/ closure capture, w/o sacrificing value semantics // no need for the WeakSet to safely "brand" normalized arrays -- get this for free // no more "term box" 1-tuple -- every term is a n-tuple with n>1 // with possible exception of the ur-symbol... the Symbol symbol // though prob don't need/want a representative tuple for this anyway // allows new "atomic" types can be defined... // an atomic is just an element with "parts" that can be mapped over // instead, components can be extracted by bespoke "projection" methods, a la mm // e.g. IntegerDigits, Numerator/Denominator, Re/Im, etc... Term = { const { tuple } = immutabletuple const REPR_KEY = Symbol.for('ƒurl:repr') const NormalTupleSet = new WeakSet() const TupleTermCache = new WeakMap() // stable expression term reconstruction from immutable tuple inputs... // when given a bare unary tuple, we can reliably (re)construct associated node tree // recurse until we get a hit in the expression node weakmap cache, or hit an atom class Term { // decides whether input argument is a tuple static isTuple (input) { return tuple.isTuple(input) } // return a normalized tuple from an arbitrary tupleable input static normalTuple (input) { // first check tuple cache to see if input has already been normalized if (NormalTupleSet.has(input)) return input // construct normalized value recursively return Term.Tuple(...input) } // recursively creates an immutable term tuple from valid inputs // throws when unhandleable input is encountered anywhere in the input structure static Tuple (...parts) { return tuple.apply(null, parts.map((part, key) => { // transform array-like part into tuple if (Array.isArray(part)) { part = tuple.apply(null, part) } if (Term.isTuple(part)) { // test for presence in NormalTupleSet (certifies validity so we can skip further recursion) if (NormalTupleSet.has(part)) return part // recurse into children and return associated tuple const normal = Term.Tuple(...part) NormalTupleSet.add(normal) return normal } else { // attempt to extract a normalized atom from what must be a primitive element const atom = Term.Atom(part) // panic if no valid atom is found if (atom == null) { return Term.panic({ part, key, parts }, 'tuple content must be atomic or tupleable sequence') } return atom } })) } static Atom (input) { switch (typeof input) { // case 'boolean': case 'symbol': case 'string': case 'bigint': return input case 'number': if (Number.isSafeInteger(input)) return BigInt(input) // TODO // default: // return Term.panic({ input }, 'atom content must be valid primitive') } } static ident (name) { // TODO prefix path based on context... and work out some sane scoping semantics... if (!name) return Term.panic({ name }, 'invalid ident name') return Symbol.for(name) } // generates unique, ephemeral symbol static gensym (name) { // TODO registered symbols and module counter, to allow these to be serializable return Symbol(name) } // create expression associated with tuple derived from bare input static from (content) { // if (content == null) throw new TypeError('Term content void') // TODO normalization pass... or just build expression from bottom up // TODO allow special forms like: // Term.from({ symbol: '...' }) // Term.from({ atom: '...' }) // Term.from({ call: '...' }) return new Term(Term.Tuple(content)) } // create expression associated with tuple derived from bare arguments static of (...content) { return Term.from(content) } static panic (data, message) { if (typeof data === 'string') { message = data data = undefined } const error = new TypeError(message) console.error(error) if (data) console.error(data) throw error } // to avoid atom/tuple ambiguity, constructor requires 1-tuple wrapper box, our "term box" constructor (input) { if (arguments.length !== 1) { return Term.panic({ arguments }, 'term constructor requires exactly 1 argument') } // input box must already be properly wrapped in a 1-tuple if (!Term.isTuple(input) || input.length !== 1) { return Term.panic({ input }, 'constructor input box must be 1-tuple') } // resolve normalized term datum from input box const box = Term.normalTuple(input) // return eagerly if a term node associated with this datum exists in cache const existing = TupleTermCache.get(box) if (existing) return existing // if box datum differs from input, input box was not fully normalized // so construct using normal box instead and return that instead if (box !== input) return new Term(box) // add this term node to cache, associated with term datum 1-tuple TupleTermCache.set(box, this) // unwrap input 1-tuple to get our potential content const content = box[0] // content must be a tuple or valid atomic... // since tuple box was already normalized this shouldn't happen if (content == null) return Term.panic({ input }, 'void term content') const isAtom = !Term.isTuple(content) if (!isAtom) { // iterate over content to validate, build out subexpression term boxes for each element // TODO be as lazy as possible in evaluating parts // we've already validated content of term, so no need to generate all child term boxes const parts = content.map(a => new Term(tuple(a))) const derived = parts.map(a => a.content) if (derived !== content) { return Term.panic({ content, derived }, 'content tuple serialized incorrectly') } // Object.defineProperties(this, { // head: { // // surface a handle to head expression // value: () => parts[0] // }, // args: { // // slice off the remainder and surface args expressions // value: () => parts.slice(1) // }, // }) } const memo = {} Object.defineProperties(this, { // our term box is the 1-tuple term box around content repr: { get: () => { if (memo.repr != null) return memo.repr if (isAtom) { memo.repr = this.content[REPR_KEY]() } else { memo.repr = `${this._head().repr}(${this._args().map(d => d.repr).join(',')})` } return memo.repr }, // enumerable: true, }, content: { value: content, enumerable: true }, // TODO kill this once refactored to use tuple as term node directly box: { value: box }, // TODO we won't need lazy instantiation of parts, since the tuple itself will be our "parts" Part: { value: (index) => { // check parts cache if (memo.parts) { const cached = memo.parts[index] if (cached) return cached } else { memo.parts = [] } const partial = this.content[index] if (partial != null) return new Term(tuple(partial)) return Term.panic({ index, term: this }, 'cannot resolve part index for term') } }, // TODO AtomQ isAtom: { value: isAtom }, }) } get isSymbol () { return this.isAtom ? typeof this.content === 'symbol' : false } // TODO isText get isString () { return this.isAtom ? typeof this.content === 'string' : false } get isInteger () { return this.isAtom ? typeof this.content === 'bigint' : false } // pygrim-specific _head () { return this.isAtom ? null : this.Part(0) } _args () { return this.isAtom ? null : this.content.slice(1).map((_,i) => this.Part(i+1)) } // TOOD move all this out into separate scopes that can be mixed in at instantiation // also, should member "method"-ish symbols implicitly evaluate "this" expression? // better yet, just getter which wraps first arg... // e.g. (3/2).Head --> Div(3,2).Head --> Head(Div(3,2)) // transform would occur *before* application of any arguments, e.g. // get Head () => { return this.constructor.Head(this) } // alternatively: pygrim`Head(${this})` // we can do all this w/o populating all symbols by using a proxy in tuple ast prototype chain? // though should be reasonable to populate symbols in a stack of proto chains? // at least logically -- we can flatten down to single proto, warn on conflicts/shadowing // AtomQ () { // // TODO Boolean atomics // } // ƒ.Head() --> Head(ƒ) ... TODO should be ƒ.Head() --> Head(ƒ)() // Head helper, which drills into term head, always returning something (eventually returning Symbol) // should have heads for all atomics: Integer, String, Symbol // Symbol is fixed point of Head for any expression // thus for atomics, Head(4) --> Integer.... Head(Head(4)) --> Symbol... Head^3(4) --> Symbol Head () { // Atomic terms always return a head of Symbol // TODO clean all this up if (!this.isAtom) return this._head() switch (typeof this.content) { case 'symbol': return Term.ident('Symbol') case 'string': return Term.ident('String') case 'bigint': return Term.ident('Integer') default: return Term.panic({ content: this.content }, 'unknown atom') } } } const IDENT_LEX = /^[a-zA-Z][a-zA-Z0-9]*$/ const ESCAPE_CLS = /\\/g const QUOTE_CLS = /[`]/g // set some repr helpers on builtin prototypes for convenience... // perfectly safe since we're using a symbol here, but still should clean this up... BigInt.prototype[REPR_KEY] = BigInt.prototype.toString String.prototype[REPR_KEY] = function () { // if string contains backslashes, return as a Text-tagged literal, otherwise as untagged template string const containsEscapement = ESCAPE_CLS.test(this) // TODO still requires escapement of `... if (containsEscapement) { return `Text\`${this}\`` } else { return `\`${this}\`` } } Symbol.prototype[REPR_KEY] = function () { // TODO need a good repr for symbols which are not valid idents const d = this.description // reflect distinction between registered vs. unique symbol const isRegistered = this === Symbol.for(d) if (isRegistered) { // only reflect symbols as bare idents when description is a valid identifier // TODO lexical space of idents could be quite a bit wider... being lazy for now... // also need proper escapement and whatnot return IDENT_LEX.test(d) ? d : `Symbol\`${d.replace(QUOTE_CLS,'\\$1')}\`` } else { // TODO keep a ordered set of ephemeral symbols seen... // annotate with index in ephemeral set return `Unique\`${d.replace(QUOTE_CLS,'\\$1')}\`` } } // TODO Number.prototype[REPR_KEY] for machine precision numbers? repr owuld always includes a `.` // etc... tuple.prototype[REPR_KEY] = function () { return this.map(a => a[REPR_KEY]()).join(',') } Object.defineProperty(tuple.prototype, Symbol.toStringTag, { configurable: true, get () { return 'Tuple' }, }) Object.defineProperty(Term.prototype, Symbol.toStringTag, { get () { // return `Term` return `Term := ${this.repr}` }, }) return Term }35:T11d9,// parse an arbitrary input into a Term node // suitable for revival as Term node parse = { // TODO config object to accept/transform literals const parseLiteral = (node) => { if (node.raw === 'null') throw new SyntaxError('no bare null') if (node.raw === 'false') throw new SyntaxError('no bare false') if (node.raw === 'true') throw new SyntaxError('no bare true') switch (typeof node.value) { case 'undefined': throw new SyntaxError('no bare undefined') case 'number': // TODO NaN, Infinity, -Infinity, ...? easy to support with configurable literals map // hex literal if (/^0x/.test(node.raw)) if (!/^0x[0-9a-fA-F]+$/.test(node.raw)) throw new SyntaxError('invalid hex literal') // octal literal if (/^0o/.test(node.raw)) if (!/^0o[0-7]+$/.test(node.raw)) throw new SyntaxError('invalid octal literal') // binary literal if (/^0b/.test(node.raw)) if (!/^0b[0-1]+$/.test(node.raw)) throw new SyntaxError('invalid binary literal') // 0-prefixed decimal... // TODO revive these in strict mode, e.g. for as a sigil for n-adic notations? if (/^0[0-9]/.test(node.raw)) throw new SyntaxError('no legacy octal literals') // what remains is required to be an integer return BigInt(node.raw) case 'bigint': return node.value case 'string': return node.value case 'symbol': throw new SyntaxError('no bare symbol') // TODO... // TODO bigint? if acorn ever gets around to it, at least... } throw new SyntaxError('unknown literal: ' + node.raw) } // TODO config object for operator maps const UNARY_OP_MAP = { '+': 'Pos', '-': 'Neg', '!': null, '~': null, } const BINARY_OP_MAP = { '+': 'Add', '-': 'Sub', '*': 'Mul', '/': 'Div', '**': 'Pow', '%': null, // Mod '>': null, // Greater '<': null, // Less '>=': null, // GreaterEqual '<=': null, // LessEqual '===': null, '!==': null, '==': null, '!=': null, '&': null, // Intersect? '|': null, // Union? Divides? '^': null, // xor? '<<': null, '>>': null, '>>>': null, '&&': null, '||': null, // also all the assignment forms, e.g. +=, -=, *=, /=, **=, %=, <<=, >>=, >>>=, ... } function parseNode(node) { switch (node.type) { // TODO Program... case 'UnaryExpression': if (UNARY_OP_MAP[node.operator]) { const ident = Term.ident(UNARY_OP_MAP[node.operator]) return Term.Tuple(ident, parseNode(node.argument)) } else { throw new SyntaxError('unsupported unary operator: ' + node.operator) } case 'BinaryExpression': if (BINARY_OP_MAP[node.operator]) { const ident = Term.ident(BINARY_OP_MAP[node.operator]) return Term.Tuple(ident, parseNode(node.left), parseNode(node.right)) } else { // TODO generic symbol for unknown binary op? throw new SyntaxError('unsupported unary operator: ' + node.operator) } case 'Literal': return parseLiteral(node) case 'Identifier': // TODO ... return Term.ident(node.name) case 'ConditionalExpression': throw new SyntaxError('no conditionals') case 'CallExpression': return Term.Tuple(parseNode(node.callee), ...node.arguments.map(parseNode)) case 'MemberExpression': // node.object.name is like instance base name // node.property.name is like instance getter name throw new SyntaxError('no member expressions:' + node.object.name + '.' + node.property.name) case 'SequenceExpression': // Tuples FTW... return Term.Tuple(Term.ident('Tuple'), ...node.expressions.map(parseNode)) case 'ArrayExpression': return Term.Tuple(Term.ident('List'), ...node.elements.map(parseNode)) case 'ArrowFunctionExpression': return Term.Tuple( Term.ident('Function'), // TODO should we define a Parameters type here? could be useful... Term.Tuple(Term.ident('Tuple'), ...node.params.map(parseNode)), parseNode(node.body) ) case 'FunctionExpression': throw new SyntaxError('no function expressions') default: console.warn('unknown node type', { node }) throw new SyntaxError('unsupported node type: ' + node.type) } } return parseNode }36:T3d2c,Term_latex = { // convert an expression term into latex function Term_latex (term, opts) { if (arguments.length < 2) console.warn('latex printer called w/o opts passed down', term) if (term.isAtom) { const atom = term.content const type = typeof atom if (type === 'symbol') { const tag = atom.description // TODO inject_vars to build pygrim_variable_names map // if (pygrim_variable_names[tag] !== null) { if (tag.length === 1) return tag if (tag === 'epsilon') return raw`\varepsilon` // return '\\' + tag if (latex_table.symbol[tag]) return latex_table.symbol[tag] return tag // } // TODO this is stupid // return raw`\operatorname{${tag}}` } else if (type === 'bigint') { return String(atom) } else if (type === 'string') { return raw`\text{${'``'}${ // TODO proper string escapement... this is just a quick hack atom.replace(/\\\\/g, '\\backslash ').replace(/([\{\}$&#^_%])/g, '\\$1').replace(/[~]/g, '\\textasciitilde ') }''}` } console.info(atom) throw new Error('not implemented') } // FIXME if (typeof term.content === 'symbol') { const tag = term.content // check latex symbol table for symbol description string let sym = latex_table.symbol[tag.description] if (sym) return sym } if (typeof term.Head !== 'function') { console.error('expected proper term instance...', term) throw new Error('Bad term head') } const head = term.Head() const tag = head.content || head if (typeof tag === 'symbol') { // TODO proper ident resolver const def = latex_defs[tag.description] if (def) return def(term, opts) // check latex symbol table for symbol description string const sym = latex_table.symbol[tag.description] if (sym) return raw`${sym} \left(${all(term._args(), opts)}\right)` console.warn('missed symbol lookup:', tag) // if unrecognized, just render as bare text for now return raw`<${tag.description}\ ::\ (${all(term._args(), opts).join(', ')})>` } console.warn({ term, head, tag }) throw new Error('NYI: ' + (tag && tag.description || term)) } const all = (list, opts) => list.map(a => Term_latex(a, opts)) const latex_defs = { // TODO work through this hack Integer: (term, opts) => term.content, // TODO lexical ident test... Symbol: (term, opts) => String(term.content.description), // Where // TODO assert arity 1 Pos: (term, opts) => raw`+{${all(term._args(), opts).join(' ')}}`, // TODO assert arity 1 Neg: (term, opts) => raw`-{${all(term._args(), opts).join(' ')}}`, Add: (term, opts) => raw`{${all(term._args(), opts).join('} + {')}}`, // TODO make this suck less... Sub: (term, opts) => raw`{${all(term._args(), opts).join('} - {')}}`, // TODO paren handling, etc... using \cdot for now, but should just be concatenation Mul: (term, opts) => raw`{${all(term._args(), opts).join(raw`}\cdot{`)}}`, // TODO assert arity 2... this is really terrible...but meh... Pow: (term, opts) => raw`{${all(term._args()).join('}^{')}}`, // TODO assert arity 2... this is really lazy... it's getting late... Div: (term, opts) => raw`\frac{${all(term._args()).join('}{')}}`, // TODO assert arity 4 Matrix2x2: (term, opts) => raw`\begin{pmatrix} ${ Term_latex(term.Part(1), opts)} & ${Term_latex(term.Part(2), opts) } \\ ${ Term_latex(term.Part(3), opts)} & ${Term_latex(term.Part(4), opts) } \end{pmatrix}`, // TODO assert arity 2 Matrix2x1: (term, opts) => raw`\begin{pmatrix} ${ Term_latex(term.Part(1), opts)} \\ ${Term_latex(term.Part(2), opts) } \end{pmatrix}`, // TODO assert arity 3 or 4 // JacobiTheta // Cases // And // Or // arity 1 Sqrt: (term, opts) => raw`\sqrt{${all(term._args(), opts).join(' ')}}`, // arity 1 Abs: (term, opts) => raw`\left|${all(term._args(), opts).join(' ')}\right|`, // arity 1 Floor: (term, opts) => raw`\left\lfloor{${all(term._args(), opts).join(' ')}}\right\rfloor`, // arity 1 Ceil: (term, opts) => raw`\left\lceil{${all(term._args(), opts).join(' ')}}\right\rceil`, // raw`\left($$\right) Tuple: (term, opts) => raw`\left(${all(term._args(), opts).join(', ')}\right)`, // raw`\left\{$$\right\}` Set: (term, opts) => raw`\left\{${all(term._args(), opts).join(', ')}\right\}`, // raw`\left[$$\right]` List: (term, opts) => raw`\left[${all(term._args(), opts).join(', ')}\right]`, // arity 1 Parentheses: (term, opts) => raw`\left(${all(term._args(), opts).join(' ')}\right)`, // arity 1 // raw`\left[$1\right]` Brackets: (term, opts) => raw`\left[${all(term._args(), opts).join(' ')}\right]`, // arity 1 // raw`\left\{$1\right\}` Braces: (term, opts) => raw`\left\{${all(term._args(), opts).join(' ')}\right\}`, // raw`$1\!\left($$)` Call: (term, opts) => raw`${Term_latex(term.Part(1), opts)}\!\left(${all(term._args().slice(1), opts).join(', ')}\right)`, // arity 2 // raw`{$1}_{$2}` Subscript: (term, opts) => raw`{${ Term_latex(term.Part(1), opts) }}_{${ Term_latex(term.Part(2), { ...opts, in_small: true }) }}`, Var: (term, opts) => raw`${all(term._args(), opts).join(', ')}`, // TODO assert arity 3 or 4 // Limit, SequenceLimit, RealLimit, LeftLimit, RightLimit, // ComplexLimit, MeromorphicLimit, SequenceLimitInferior, SequenceLimitSuperior // Minimum, Maximum, ArgMin, ArgMax, ArgMinUnique, ArgMaxUnique, // Supremum, Infimum, Zeros, UniqueZero, Solutions, UniqueSolution // Derivative, RealDerivative, ComplexDerivative, ComplexBranchDerivative, MeromorphicDerivative // TODO assert arity 2 // Integral // TODO assert arity 3 or 4 // IndefiniteIntegralEqual, RealIndefiniteIntegralEqual, ComplexIndefiniteIntegralEqual // TODO assert arity 1, 2 or 3 // Sum, Product // TODO assert arity 2 or 3 // PrimeSum, PrimeProduct DivisorSum: (term, opts) => raw`\sum${tex_DivisorSumOrProduct(term, opts)}`, DivisorProduct: (term, opts) => raw`\prod${tex_DivisorSumOrProduct(term, opts)}`, // TODO assert arity 3 // TODO special form when first and second arg are equal? ComplexZeroMultiplicity: (term, opts) => raw`\mathop{\operatorname{ord}}\limits_{${ Term_latex(term.Part(1), opts)}=${Term_latex(term.Part(2), opts)} } ${Term_latex(term.Part(3), opts)}`, // TODO assert arity 3 // TODO special form when first and second arg are equal? Residue: (term, opts) => raw`\mathop{\operatorname{Res}}\limits_{${ Term_latex(term.Part(1), opts)}=${Term_latex(term.Part(2), opts)} } ${Term_latex(term.Part(3), opts)}`, // TODO assert arity 3? CongruentMod: (term, opts) => raw`${ Term_latex(term.Part(1), opts) } \equiv ${ Term_latex(term.Part(2), opts) } \pmod ${ Term_latex(term.Part(3), opts) }`, // TODO assert arity 1 Odd: (term, opts) => raw`${Term_latex(term.Part(1), opts)} \text{ odd}`, // TODO assert arity 1 Even: (term, opts) => raw`${Term_latex(term.Part(1), opts)} \text{ even}`, // TODO assert arity 1 ZZGreaterEqual: (term, opts) => raw`\mathbb{Z}_{\ge ${Term_latex(term.Part(1), opts)}}`, // TODO assert arity 1 // TODO special form when arg is an int? ZZLessEqual: (term, opts) => raw`\mathbb{Z}_{\le ${Term_latex(term.Part(1), opts)}}`, // TODO assert arity 2 // TODO special form when first arg is an int? ZZBetween: (term, opts) => raw`\{${Term_latex(term.Part(1), opts)}, ${Term_latex(term.Part(1), opts)} + 1, \ldots ${Term_latex(term.Part(2), opts)}\}`, // TODO assert arity 2 // Interval, ClosedInterval, OpenInterval, ClosedOpenInterval, OpenClosedInterval // arity 2 RealBall: (term, opts) => raw`\left[${Term_latex(term.Part(1), opts)} \pm ${Term_latex(term.Part(2), opts)}\right]`, // arity 1 BernsteinEllipse: (term, opts) => raw`\mathcal{E}_{${Term_latex(term.Part(1), opts)}}`, // arity 1 Conjugate: (term, opts) => raw`\overline{${Term_latex(term.Part(1), opts)}}`, // arity 3 // TODO Y U NO USE 2nd ARG? SetBuilder: (term, opts) => raw`\left\{ ${Term_latex(term.Part(1), opts)} : ${Term_latex(term.Part(3), opts)} \right\}`, // arity 1 // TODO this one has various common forms... Cardinality: (term, opts) => raw`\# ${Term_latex(term.Part(1), opts)}`, Decimal: (term, opts) => { const args = term._args() // assert arity 1 if (args.length !== 1) throw new TypeError('Decimal arity ≠ 1') let text = term.Part(1).content if (/e/.test(text)) { let [ mant, expo ] = text.split('e') if (!/[.]/.test(mant)) mant += '.' if (/^\+/.test(expo)) expo = expo.slice(1) return raw`${mant} \cdot 10^{${expo}}` } if (!/[.]/.test(text)) text += '.' return text }, // ... // arity 1 // Factorial // arity 1 // DoubleFactorial RisingFactorial: (term, opts) => raw`\left(${Term_latex(term.Part(1), opts)}\right)_{${Term_latex(term.Part(2), opts)}}`, FallingFactorial: (term, opts) => raw`\left(${Term_latex(term.Part(1), opts)}\right)^{\underline{${Term_latex(term.Part(2), opts)}}}`, Binomial: (term, opts) => raw`{${all(term._args(), opts).join(raw` \choose `)}}`, StirlingCycle: (term, opts) => raw`\left[{${all(term._args(), opts).join(raw` \atop `)}}\right]`, StirlingS1: (term, opts) => raw`s\!\left(${all(term._args(), opts).join(', ')}\right)`, StirlingS2: (term, opts) => raw`\left\{{${all(term._args(), opts).join(raw` \atop `)}}\right\}`, // LambertW // arity 4 AsymptoticTo: (term, opts) => raw`${Term_latex(term.Part(1), opts)} \sim ${Term_latex(term.Part(2), opts)}, \; ${Term_latex(term.Part(3), opts)} \to ${Term_latex(term.Part(4), opts)}`, // arity 1 Not: (term, opts) => raw`\operatorname{not} \left(${all(term._args(), opts).join(' ')}\right)`, Implies: (term, opts) => raw`\left(${all(term._args(), opts).join(raw`\right) \implies \left(`)}\right)`, Equivalent: (term, opts) => raw`\left(${all(term._args(), opts).join(raw`\right) \iff \left(`)}\right)`, // arity 3 EqualAndElement: (term, opts) => raw`${Term_latex(term.Part(1), opts)} = ${Term_latex(term.Part(2), opts)} \in ${Term_latex(term.Part(3), opts)}`, // arity 2 KroneckerDelta: (term, opts) => raw`\delta_{(${all(term._args(), {...opts, in_small: true }).join(', ')})}`, // LegendreSymbol Lattice: (term, opts) => raw`\Lambda_{(${all(term._args(), {...opts, in_small: true }).join(', ')})}`, // TODO assert arity 2 DomainCodomain: (term, opts) => raw`${all(term._args(), opts).join(raw` \rightarrow `)}`, // TODO assert arity 2 ModularGroupAction: (term, opts) => raw`${all(term._args(), opts).join(raw` \circ `)}`, // TODO assert arity 1 PrimitiveReducedPositiveIntegralBinaryQuadraticForms: (term, opts) => raw`\mathcal{Q}^{*}_{${all(term._args(), opts)}}`, // TODO assert arity 4 HypergeometricUStarRemainder: (term, opts) => raw`R_{${Term_latex(term.Part(1), opts)}}\!\left(${all(term._args().slice(1), opts).join(',')}\right)`, // arity 2 or 3 DirichletCharacter: (term, opts) => raw`\chi{${Term_latex(term.Part(1), opts)} \, . \, ${Term_latex(term.Part(2), opts)}}` + (term._args().length > 2 ? raw`\!\left(${Term_latex(term.Part(3), opts)}\right)` : ''), // arity 1? PrimitiveDirichletCharacters: (term, opts) => raw`G_{${Term_latex(term.Part(1), opts)}}^{\text{primitive}}`, // arity 2 GaussSum: (term, opts) => raw`G_{${Term_latex(term.Part(1), opts)}}\!\left(${Term_latex(term.Part(2), opts)}\right)`, // arity 1 or 2 StieltjesGamma: (term, opts) => raw`\gamma_{${Term_latex(term.Part(1), { ...opts, in_small: true })}}` + (term._args().length > 1 ? raw`\!\left(${all(term._args().slice(1), opts)}\right)` : ''), // arity 2 FormalPowerSeries: (term, opts) => raw`${Term_latex(term.Part(1), opts)}[[${Term_latex(term.Part(2), opts)}]]`, // arity 2 FormalLaurentSeries: (term, opts) => raw`${Term_latex(term.Part(1), opts)}(\!(${Term_latex(term.Part(2), opts)})\!)`, // arity 3 SeriesCoefficient: (term, opts) => raw`[{${Term_latex(term.Part(1), opts)}}^{${Term_latex(term.Part(2), opts)}}] ${Term_latex(term.Part(3), opts)}`, // arity 2 // raw`$1 \text{ is the generator of } ${Term_latex(term.Part(2), opts)}` FormalGenerator: (term, opts) => raw`${Term_latex(term.Part(1), opts)} \text{ is the generator of } ${Term_latex(term.Part(2), opts)}`, // arity 1 // Spectrum // arity 1 // Det // ForAll // Exists // raw`\log_{$2}\!\left($1\right) \bmod $3` DiscreteLog: (term, opts) => raw`\log_{${Term_latex(term.Part(2), {...opts, in_small: true })}}\!\left(${Term_latex(term.Part(1), opts)}\right) \bmod ${Term_latex(term.Part(3), opts)}`, // QSeriesCoefficient // EqualQSeriesEllipsis // arity 2 // raw`$1 \; (\text{nearest } $2 \text{D})` NearestDecimal: (term, opts) => raw`${Term_latex(term.Part(1), opts)} \; (\text{nearest } ${Term_latex(term.Part(2), opts)} \text{D})`, // FIXME... just throwing things against the wall here... Equal: (term, opts) => raw`{${all(term._args(), opts).join('} = {')}}`, Formula: (term, opts) => all(term._args(), opts).join(' '), Element: (term, opts) => all(term._args(), opts).join(raw` \in `), Assumptions: (term, opts) => raw`\text{\color{gray}Assumptions:}\ ${all(term._args(), opts).join(', ')}`, SymbolDefinition: (term, opts) => raw`\text{\color{gray}Symbol:}\ ${ // TODO katex supports \url, \href... but not within observablehq (prob a bug in tex template helper) // TODO helper to just dump out raw text mode string in tex raw`\text{${term.Part(1).content.description}}` }\ —\ ${ Term_latex(term.Part(2), opts) }\ —\ ${ Term_latex(term.Part(3), opts) }`, Description: (term, opts) => all(term._args(), opts).join(raw`\ `), // ** extras // a matrix is just a 2d array // TODO take max length in term parts? assert same length? Matrix: (term, opts) => raw`\left(\begin{array}{${ Array.from(term.Part(1).content.slice(1)).fill('c').join('') }} ${ term._args().map(a => all(a._args(), opts).join(' & ')).join(raw` \\ `) } \end{array}\right)`, Function: (term, opts) => raw`${Term_latex(term.Part(1), opts)} \mapsto ${Term_latex(term.Part(2), opts)}`, Composition: (term, opts) => raw`${all(term._args(), opts).join(raw` \circ `)}`, } const tex_DivisorSumOrProduct = (term, opts) => { const args = term._args() const [ Formula, Var, Num, Cond ] = args const f = Term_latex(Formula, opts) const v = Term_latex(Var, opts) const n = Term_latex(Num, { ...opts, in_small: true }) if (args.length === 3) { return raw`_{${v} \mid ${n}} ${f}` } else if (args.length === 4) { const c = Term_latex(Cond, { ...opts, in_small: true }) return raw`_{${v} \mid ${n},\, ${c}} ${f}` } else { throw new Error('tex_DivisorSumOrProduct -- bad arity: ' + args.length) } } return (term, opts = {}) => Term_latex(term, opts) }37:T1736,// TODO we really need a canonical db of named character entities, or perhaps "iconographemes"... // e.g. https://reference.wolfram.com/language/guide/ListingOfNamedCharacters.html // the idea being to capture the common "emic units" of mathematical/scientific/computational symbolism... // for example, [ρ](https://reference.wolfram.com/language/ref/character/Rho.html) // this has a variety of context-specific meanings, but here is used as representative for RiemannZetaZero // it would be handy to collect up some of the various allographs and interpretations as entries // this could be a useful resource in its own right, but also useful for disambiguation... // interactive sessions allow proactive warnings of ambiguous interpretations, allowing refinements // perhaps a better example of ambiguity: ℍ -- in fungrim, the upper complex half-plane // but very often, represents the algebra of quaternions... // what happens when fungrim wants to say anything about quaternions? perhaps ℚ? nope... damn Rats latex_table = ({ infix: { Mod: '\\bmod', Element: '\\in', NotElement: '\\notin', SetMinus: '\\setminus', Union: '\\cup', Intersection: '\\cap', Less: '<', LessEqual: '\\le', Greater: '>', GreaterEqual: '\\ge', Equal: '=', Unequal: '\\ne', Subset: '\\subset', SubsetEqual: '\\subseteq', Divides: '\\mid', }, subscript: { BernoulliB: 'B', Fibonacci: 'F', BellNumber: 'B', HarmonicNumber: 'H', PrimeNumber: 'p', RiemannZetaZero: '\\rho', LambertWPuiseuxCoefficient: '\\mu', DirichletGroup: 'G', ConreyGenerator: 'g', KeiperLiLambda: '\\lambda', }, subscript_pair: { DirichletLZero: '\\rho', LegendrePolynomialZero: 'x', GaussLegendreWeight: 'w', GeneralizedBernoulliB: 'B', }, subscript_call: { BernoulliPolynomial: 'B', LegendrePolynomial: 'P', ChebyshevT: 'T', ChebyshevU: 'U', HermitePolynomial: 'H', HilbertClassPolynomial: 'H', EisensteinG: 'G', EisensteinE: 'E', DivisorSigma: '\\sigma', IncompleteBeta: '\\mathrm{B}', IncompleteBetaRegularized: 'I', PolyGamma: '\\psi', PolyLog: '\\operatorname{Li}', JacobiThetaEpsilon: '\\varepsilon', JacobiThetaPermutation: 'S', // JacobiTheta: '\\theta', SquaresR: 'r', StirlingSeriesRemainder: 'R', }, symbol: { True_: '\\operatorname{True}', // \top (⊤)? False_: '\\operatorname{False}', // \bot (⊥)? perhaps too easy to confuse with \perp (⟂)? ConstPi: '\\pi', ConstI: 'i', // 𝒾? 𝕚? ⅈ? ConstE: 'e', // ℯ? 𝕖? ConstGamma: '\\gamma', ConstCatalan: 'G', GoldenRatio: '\\varphi', 'Infinity': '\\infty', UnsignedInfinity: '{\\tilde \\infty}', GammaFunction: '\\Gamma', LogGamma: '\\log \\Gamma', UpperGamma: '\\Gamma', Erf: '\\operatorname{erf}', Erfc: '\\operatorname{erfc}', Erfi: '\\operatorname{erfi}', DigammaFunction: '\\psi', DedekindEta: '\\eta', DedekindEtaEpsilon: '\\varepsilon', DedekindSum: 's', ModularJ: 'j', ModularLambda: '\\lambda', WeierstrassP: '\\wp', WeierstrassSigma: '\\sigma', WeierstrassZeta: '\\zeta', EllipticK: 'K', EllipticE: 'E', EulerQSeries: '\\phi', PartitionsP: 'p', MoebiusMu: '\\mu', HardyRamanujanA: 'A', Sin: '\\sin', Sinh: '\\sinh', Cos: '\\cos', Cosh: '\\cosh', Tan: '\\tan', Tanh: '\\tanh', Cot: '\\cot', Coth: '\\coth', Sec: '\\sec', Sech: '\\sech', Csc: '\\csc', Csch: '\\csch', Exp: '\\exp', Log: '\\log', Atan: '\\operatorname{atan}', Acos: '\\operatorname{acos}', Asin: '\\operatorname{asin}', Acot: '\\operatorname{acot}', Atanh: '\\operatorname{atanh}', Acosh: '\\operatorname{acosh}', Asinh: '\\operatorname{asinh}', Acoth: '\\operatorname{acoth}', Atan2: '\\operatorname{atan2}', Sinc: '\\operatorname{sinc}', Hypergeometric0F1: '\\,{}_0F_1', Hypergeometric1F1: '\\,{}_1F_1', Hypergeometric2F1: '\\,{}_2F_1', Hypergeometric2F0: '\\,{}_2F_0', Hypergeometric3F2: '\\,{}_3F_2', HypergeometricU: 'U', HypergeometricUStar: 'U^{*}', Hypergeometric0F1Regularized: '\\,{}_0{\\textbf F}_1', Hypergeometric1F1Regularized: '\\,{}_1{\\textbf F}_1', Hypergeometric2F1Regularized: '\\,{}_2{\\textbf F}_1', Hypergeometric2F0Regularized: '\\,{}_2{\\textbf F}_0', Hypergeometric3F2Regularized: '\\,{}_3{\\textbf F}_2', BesselJ: 'J', BesselI: 'I', BesselY: 'Y', BesselK: 'K', HankelH1: 'H^{(1)}', HankelH2: 'H^{(2)}', AiryAi: '\\operatorname{Ai}', AiryBi: '\\operatorname{Bi}', LogIntegral: '\\operatorname{li}', GCD: '\\gcd', LCM: '\\operatorname{lcm}', XGCD: '\\operatorname{xgcd}', Totient: '\\varphi', Sign: '\\operatorname{sgn}', Csgn: '\\operatorname{csgn}', Arg: '\\arg', Min: '\\min', Max: '\\max', PP: '\\mathbb{P}', ZZ: '\\mathbb{Z}', QQ: '\\mathbb{Q}', RR: '\\mathbb{R}', CC: '\\mathbb{C}', HH: '\\mathbb{H}', AlgebraicNumbers: '\\overline{\\mathbb{Q}}', UnitCircle: '\\mathbb{T}', PrimePi: '\\pi', SL2Z: '\\operatorname{SL}_2(\\mathbb{Z})', PSL2Z: '\\operatorname{PSL}_2(\\mathbb{Z})', ModularGroupFundamentalDomain: '\\mathcal{F}', ModularLambdaFundamentalDomain: '\\mathcal{F}_{\\lambda}', PowerSet: '\\mathscr{P}', Ellipsis: '\\ldots', Spectrum: '\\operatorname{spec}', Det: '\\operatorname{det}', RiemannHypothesis: '\\operatorname{RH}', GeneralizedRiemannHypothesis: '\\operatorname{GRH}', RiemannZeta: '\\zeta', HurwitzZeta: '\\zeta', DirichletL: 'L', DirichletLambda: '\\Lambda', BetaFunction: '\\mathrm{B}', LandauG: 'g', LiouvilleLambda: '\\lambda', DeBruijnNewmanLambda: '\\Lambda', RiemannXi: '\\xi', LerchPhi: '\\Phi', } })38:Tb09,// specific typesetting symbols typesetting = ({ // TODO opts like ScriptSizeMultipliers, ScriptMinSize SubscriptBox: { ToTeX (opts) { return raw`{${this.Part(1).toTex(opts)}}_{${ this._args().slice(1).map(a => a.ToTeX({ ...opts, small: true })).join(',') }}` }, // _TeXTemplate: '{$1}_{$$}', // _TeXTemplateOverrides: { // $$: { small: true, join: ', ' }, // }, }, SuperscriptBox: { // assert arity 2? ToTeX (opts) { return raw`{${this.Part(1).toTex(opts)}}^{${ this.Part(2).ToTeX({ ...opts, small: true }) }}` }, // _TeXTemplate: '{$1}^{$$}', // _TeXTemplateOverrides: { // $$: { small: true, join: ', ' }, // }, }, SubsuperscriptBox: { // assert arity 3? ToTeX (opts) { return raw`{${this.Part(1).toTex(opts)}}_{${ this.Part(2).ToTeX({ ...opts, small: true }) }}^{${ this.Part(3).ToTeX({ ...opts, small: true }) }}` }, // _TeXTemplate: '{$1}_{$2}^{$3}', // _TeXTemplateOverrides: { // $2: { small: true }, // $3: { small: true }, // }, }, // TODO SupersubscriptBox? ...controls wrapping order, which sup/sub script to be variadic UnderscriptBox: { // \underset{$$}{$1} ToTeX (opts) { return raw`\underset{${ this._args().slice(1).map(a => a.ToTeX({ ...opts, small: true })).join(',') }}${this.Part(1).toTex(opts)}` } // _TeXTemplate: '\\underset{$$}{$1}', // _TeXTemplateOverrides: { // $$: { small: true, join: ', ' }, // }, }, OverscriptBox: { ToTeX (opts) { return raw`\overset{${this.Part(1).ToTex(opts)}}^{${ this._args().slice(1).map(a => a.ToTeX({ ...opts, small: true })).join(',') }}` }, // _TeXTemplate: '\\overset{$$}{$1}', // _TeXTemplateOverrides: { // $$: { small: true, join: ', ' }, // }, }, UnderoverscriptBox: { // assert arity 3? ToTeX (opts) { return raw`\underset{${ this.Part(2).ToTex({ ...opts, small: true }) }}{\overset{${ this.Part(3).ToTeX({ ...opts, small: true }) }}{${ this.Part(1).ToTex(opts) }}}` } // // TODO default ToTeX which can interpret templates like this... // _TeXTemplate: '\\underset{$2}{\\overset{$3}{$1}}', // _TeXTemplateOverrides: { // $2: { small: true }, // $3: { small: true }, // }, }, // TODO OverunderscriptBox? ...controls wrapping order, which over/under script to be variadic }) /* white square dotted: '⬚' white square: '□' raised square: '⸋' asterisk square: '⧆' '▫' // ◻ combining enclosing square: ' ⃞' \u20DE combining square below: ' ̻' \u033B Underscript: '□̻' Superscript: '□⸋' Subscript: '□ ̻' Subsuperscript: '□⸋̻' */39:T161f,inject_system_builtins = (scope) => { const inject_builtin = (str) => { for (let symbol_name of str.replace(/\r?\n/g, ' ').trim().split(/\s+/g)) { // TODO context... scope[symbol_name] = Term.ident(symbol_name) // scope.Expr({ symbol_name }) } } const inject_vars = inject_builtin // TODO True, False? inject_builtin(` True_ False_ Parentheses Brackets Braces Ellipsis Call Subscript Unknown Undefined Where Set List Tuple SetBuilder PowerSet Union Intersection SetMinus Not And Or Equivalent Implies Cardinality Element NotElement Subset SubsetEqual ForAll Exists EqualAndElement Rings CommutativeRings Fields PP ZZ QQ RR CC HH AlgebraicNumbers ZZGreaterEqual ZZLessEqual ZZBetween ClosedInterval OpenInterval ClosedOpenInterval OpenClosedInterval RealBall UnitCircle OpenDisk ClosedDisk BernsteinEllipse InteriorClosure Interior Decimal Equal Unequal Greater GreaterEqual Less LessEqual Pos Neg Add Sub Mul Div Mod Inv Pow CongruentMod Odd Even Max Min Sign Csgn Abs Floor Ceil Arg Re Im Conjugate NearestDecimal Minimum Maximum ArgMin ArgMax ArgMinUnique ArgMaxUnique Solutions UniqueSolution Supremum Infimum Limit SequenceLimit RealLimit LeftLimit RightLimit ComplexLimit MeromorphicLimit SequenceLimitInferior SequenceLimitSuperior Derivative RealDerivative ComplexDerivative ComplexBranchDerivative MeromorphicDerivative Sum Product PrimeSum DivisorSum PrimeProduct DivisorProduct Integral IndefiniteIntegralEqual RealIndefiniteIntegralEqual ComplexIndefiniteIntegralEqual AsymptoticTo FormalGenerator FormalPowerSeries FormalLaurentSeries SeriesCoefficient HolomorphicDomain Poles BranchPoints BranchCuts EssentialSingularities Zeros UniqueZero AnalyticContinuation ComplexZeroMultiplicity Residue Infinity UnsignedInfinity Sqrt NthRoot Log LogBase Exp Sin Cos Tan Sec Cot Csc Asin Acos Atan Atan2 Asec Acot Acsc Sinh Cosh Tanh Sech Coth Csch Asinh Acosh Atanh Asech Acoth Acsch Sinc LambertW LambertWPuiseuxCoefficient ConstPi ConstE ConstGamma ConstI GoldenRatio ConstCatalan Binomial Factorial DoubleFactorial GammaFunction LogGamma DigammaFunction PolyGamma RisingFactorial FallingFactorial HarmonicNumber StirlingSeriesRemainder Erf Erfc Erfi UpperGamma LowerGamma BernoulliB BernoulliPolynomial EulerE EulerPolynomial StirlingCycle StirlingS1 StirlingS2 BellNumber RiemannZeta RiemannZetaZero BesselJ BesselI BesselY BesselK HankelH1 HankelH2 CoulombF CoulombG CoulombH CoulombC CoulombSigma Hypergeometric0F1 Hypergeometric1F1 Hypergeometric2F1 Hypergeometric2F0 Hypergeometric3F2 HypergeometricU HypergeometricUStar Hypergeometric0F1Regularized Hypergeometric1F1Regularized Hypergeometric2F1Regularized Hypergeometric2F0Regularized Hypergeometric3F2Regularized HypergeometricUStarRemainder AiryAi AiryBi LegendrePolynomial LegendrePolynomialZero GaussLegendreWeight HermitePolynomial ChebyshevT ChebyshevU DedekindEta EulerQSeries DedekindEtaEpsilon DedekindSum JacobiTheta JacobiThetaEpsilon JacobiThetaPermutation Divides GCD LCM XGCD DivisorSigma MoebiusMu Totient SquaresR LiouvilleLambda LegendreSymbol JacobiSymbol KroneckerSymbol Fibonacci PartitionsP HardyRamanujanA KroneckerDelta Lattice WeierstrassP WeierstrassZeta WeierstrassSigma PrimeNumber PrimePi RiemannHypothesis LogIntegral LandauG Matrix2x2 Matrix2x1 Spectrum Det SL2Z PSL2Z ModularGroupAction ModularGroupFundamentalDomain ModularLambdaFundamentalDomain ModularJ ModularLambda PrimitiveReducedPositiveIntegralBinaryQuadraticForms HilbertClassPolynomial DirichletCharacter DirichletGroup PrimitiveDirichletCharacters ConreyGenerator DiscreteLog Cases Otherwise HurwitzZeta DirichletL GeneralizedBernoulliB RiemannXi StieltjesGamma KeiperLiLambda DeBruijnNewmanLambda DirichletLZero GeneralizedRiemannHypothesis DirichletLambda GaussSum JacobiSum EisensteinG EisensteinE EllipticK EllipticE QSeriesCoefficient EqualQSeriesEllipsis BetaFunction IncompleteBeta IncompleteBetaRegularized `) inject_builtin(` Var Entry Formula ID Assumptions References Variables DomainCodomain Description Table TableRelation TableValueHeadings TableHeadings TableColumnHeadings TableSplit TableSection Topic Title DefinitionsTable Section Subsection SeeTopics Entries EntryReference TopicReference SourceForm SymbolDefinition Image ImageSource `) inject_builtin(` Var Entry Formula ID Assumptions References Variables DomainCodomain Description Table TableRelation TableValueHeadings TableHeadings TableColumnHeadings TableSplit TableSection Topic Title DefinitionsTable Section Subsection SeeTopics Entries EntryReference TopicReference SourceForm SymbolDefinition Image ImageSource `) // symbols we don't want to show in entry definition listings // exclude_symbols = new Set([ Set, List, Tuple, And, Or, Implies, Equivalent, Not, Element, NotElement, Union, Intersection, SetMinus, Subset, SubsetEqual]) inject_vars(`a b c d e f g h i j k l m n o p q r s t u v w x y z`) inject_vars(`A B C D E F G H I J K L M N O P Q R S T U V W X Y Z`) inject_vars(`alpha beta gamma delta epsilon zeta eta theta iota kappa mu nu xi pi rho sigma tau phi chi psi omega ell`) inject_vars(`Alpha Beta Gamma Delta Epsilon Zeta Eta Theta Iota Kappa Mu Nu Xi Pi Rho Sigma Tau Phi Chi Psi Omega`) }3a:T6bf,// simple fungrim entry html, e.g. // pygrim`Entry(ID("04217b"), // SymbolDefinition(HurwitzZeta, HurwitzZeta(s, a), "Hurwitz zeta function")) // ` // TODO do this in a recursive ToHTML or some such... // or better yet, as structured markdown content render_Entry = (term, opts = {}) => { const id = term.Part(1).Part(1).content const defTerm = term.Part(2) const symbol = defTerm.Part(1).content.description const title = defTerm.Part(3).content const summaryBlock = html`

${id} ${title}

` const detailsBlock = html`

... ${tex`${Term_latex(defTerm.Part(2))}`}

` const entry = html`

${summaryBlock} ${detailsBlock}

Source code for this entry:

${
        // TODO this ain't quite right... need a way to get back true fungrim-compat repr
        term.repr
      }

` // add open toggle handler, just because... entry.addEventListener('toggle', event => { if (entry.open) { console.log(id, 'opened') } else { console.log(id, 'closed') } }) // disable highlighting on double-click summaryBlock.addEventListener('mousedown', event => { if (event.detail > 1) event.preventDefault() }, false) return entry }3b:[] 32:{"id":"db9bd04304399892","slug":"furl-expression-builder","title":"ƒurl expression builder","thumbnail":"3085d85efc768093b69aa256b22a021958b4530f502f5c10f4cd3ac63ea54495","access_level":"public","create_time":"$D2019-09-20T21:45:13.123Z","update_time":"$D2020-01-28T02:25:55.843Z","view_time":null,"first_public_time":"$D2019-09-21T03:39:19.828Z","has_unpublished_edits":null,"fork":false,"stars":3,"starred":false,"owner":{"type":"team","id":"01c5b3348f0ad41e","login":"follymath","name":"ƒ","avatar_url":"https://avatars-next.observableusercontent.com/6ab71fe2b6ec1b0072af6ff766fbf76def55b1e24d5463f2deb67e7274337e67","tier":"starter_2024"},"version":1574,"publish_version":1574,"role":null,"authored":false,"authors":[{"type":"individual","id":"e83e96b3489ba704","login":"follymath","name":"ƒ","avatar_url":"https://avatars-next.observableusercontent.com/6ab71fe2b6ec1b0072af6ff766fbf76def55b1e24d5463f2deb67e7274337e67","tier":null}],"members":[{"type":"individual","id":"e83e96b3489ba704","login":"follymath","name":"ƒ","avatar_url":"https://avatars-next.observableusercontent.com/6ab71fe2b6ec1b0072af6ff766fbf76def55b1e24d5463f2deb67e7274337e67","tier":null,"role":"editor"}],"comments":[],"custom_thumbnail":false,"trashed":false,"lapsed":null,"subscribed":null,"forks":4,"collection":null,"type":"notebook","body":{"title":"ƒurl expression builder","cells":[{"id":0,"value":"md`# ƒurl expression builder`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":228,"value":"md`---\n## [\\`pygrim\\`](https://github.com/fredrik-johansson/fungrim)-esque AST\n\nThe \\`Term\\` class represents an expression node -- where each expression is identified with an immutable 1-tuple \"term box\" around an immutable value. A value can be an atom (integers, strings, or symbols), or an immutable tuple. This gives us structual equality semantics both for terms (nodes of our AST), and their underlying tuple \"content\".\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":2,"value":"$34","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":51,"value":"Term.of(T(Symbol.for('x'),3,T(Symbol.for('Tuple'),3,2),4n,'5\"6`7\\'8\\\\9'))","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":53,"value":"Term.of(T(5,T(1n,3)))","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":61,"value":"Term.of(1,2,3)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":153,"value":"// Term.from respects only one arg, a la Array.from\nTerm.from(1,2,3) === Term.from(1)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":70,"value":"Term.of(1,[2,3])","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":66,"value":"Term.of(1,[2],3)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":56,"value":"// value equality with noramlized tuples\nTerm.Tuple(3,2.0,[9n,'ab`c']) === T(3n,2n,T(9n,'ab`c'))","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":45,"value":"Term.Tuple(3,2.0,[9n,'a\"b`c']) === T(3n,2n,T(9n,\"a\\\"b`c\"))","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":40,"value":"Term.of(Term.ident('Foo'),[5,[1n,3]])","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":140,"value":"Term.of(Term.gensym('Foo'),[5,[1n,3]])","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":16,"value":"md`---\n## [\\`fungrim\\`](http://fungrim.org/)-compatible parser\n\nParse arbitrary fungrim expressions using acorn js parser. As it happens, fungrim's subset of python is\nlargely compatible with modern javascript, so we can leverage some of the goodies from the rich\necosystem of javascript parsers. With a little preprocessing (to strip out the python import declaration)\nwe could even support interpretation of the \\`make_entry\\` and \\`def_Topic\\` methods, and interpet the existing\nformula definitions in [\\`pygrim/formulas/*.py\\`](https://github.com/fredrik-johansson/fungrim/tree/master/pygrim/formulas) files in place.\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":84,"value":"pygrim_parse(`\n Entry(\n ID(\"9ee8bc\"),\n Formula(Equal(RiemannZeta(s), Mul(Mul(Mul(Mul(2, Pow(Mul(2, ConstPi), Sub(s, 1))), Sin(Div(Mul(ConstPi, s), 2))), GammaFunction(Sub(1, s))), RiemannZeta(Sub(1, s))))),\n Variables(s),\n Assumptions(And(Element(s, CC), NotElement(s, ZZGreaterEqual(1))), And(Element(s, FormalPowerSeries(CC, x)),NotElement(s, ZZGreaterEqual(1)))))\n`)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":235,"value":"md`\nBecause we're just interpreting the acorn parse tree, not attempting to evaluate it as javascript, we can even support all of fungrim's operator overloading syntax (and more).\n`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":189,"value":"pygrim_parse(`3*2**-7`)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":237,"value":"pygrim_parse(`3*Var(x)**(-1/Var(y))`)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":241,"value":"md`\nThis also means we can interpret arbitrary-precision integers, as we have access to the \\`raw\\` token content of parse node. We could support arbitrary-precision bignums -- and even hook acorn as needed to support other literal forms.\n`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":167,"value":"pygrim_parse(`\n Expr(222920100000010101282883838388182)(\n SomeOtherExp('222920100000010101282883838388182')\n )\n`)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":79,"value":"function pygrim_parse(input) {\n // wrap input with arrow function and parse\n const { body: [{ expression: { body } }] } = acorn.parse(`() => ` + input.toString())\n return Term.of(parse(body))\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":262,"value":"md`\nLet's surface pygrim parser as a \\`pygrim\\` template literal, because why not?\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":261,"value":"pygrim = (strings, ...args) => {\n let input\n // take regular string input as well\n if (typeof strings === 'string') {\n input = [strings, ...args].join('')\n } else {\n input = strings.raw.map((s,i) => s + (args[i] == null ? '' : String(args[i]))).join('')\n }\n // FIXME we have to unwrap input, since we end up with an extra bit...\n return pygrim_parse(input)._head()\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":293,"value":"pygrim`3`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":260,"value":"pygrim`1/3`.repr === \"Div(1,3)\" === Term.of(Term.ident('Div'), 1, 3)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1413,"value":"pygrim`2**2`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":369,"value":"pygrim('1 - x**2')","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":259,"value":"pygrim`7*x**2 - 3*x + 1`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":332,"value":"// we even get equality for ast-equivalent inputs...\npygrim`Mul(2, ConstPi)` === pygrim`2 * ConstPi`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":12,"value":"$35","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":258,"value":"md`---\n## Expression Builder\n\nTerm nodes can be wrapped with in \"builder\" facade, allowing for a more literate API for authoring expressions from within the host environment...\n\nTODO...\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":257,"value":"md`\n### Global scope hack...\n\nHere's a mildly amusing, [truly insane proxy hack](https://2ality.com/2016/11/trace-globals-proxy.html) for hooking into the global scope.\n\nWe can also use some \\`with\\` shenanigans within \\`new Function\\` indirect evals...\n`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":256,"value":"// // a hideous global scope hack (once we surface the builder)\n// (new Function('ƒ', `with (ƒ) {\n// return Add(3,7)(17)()\n// }`\n// ))(ƒg)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":255,"value":"md`---\n## Latex Printer\n\nTODO...\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":254,"value":"Term_render = (term, opts = {}) => {\n const str = Term_latex(term, opts)\n return opts.block ? tex.block`${str}` : tex`${str}`\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":253,"value":"$36","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":249,"value":"$37","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":339,"value":"tex`${Term_latex(Term.of(Term.ident('Sqrt'),17))}`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":343,"value":"// or equivalently:\ntex`${Term_latex(pygrim`Sqrt(17)`)}`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":350,"value":"md`\nYou can use these right in place in markdown...\n\n${tex`${Term_latex(pygrim`Abs(Sqrt(17) - x**2)`)}`}\n\nPass option to render in display form...\n\n${Term_render(pygrim`Floor(Sqrt(17)/2*x**2-1)`, { block: true })}\n`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":251,"value":"// pygrim returns a Term object\npygrim`3 + 2`.Head()","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":359,"value":"md`\nLet's build a little convenience to render pygrim input as latex directly (ultimately all of this would get moved into Term, but want to tighten it up first)...\n`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":360,"value":"// TODO surfae as a template helper as well...\n// also, move Term_latex serialiation into Term itself...\ngrimtex = (...args) => tex`${Term_latex(pygrim.apply(null, args))}`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":392,"value":"pygrim`3+ConstPi`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":316,"value":"md`\n\nVarious fences work:\n* ${grimtex`Abs(2*x-ConstPi)`}\n* ${grimtex`Floor(x+2*ConstI*ConstPi)+Ceil(1/x)`}\n\nThis is less ugly using pygrim template literal:\n* ${grimtex`3 + 2`}\n* ${grimtex`+3 - x/2`}\n* ${grimtex`RiemannZeta(s) - 3/2`}\n* ${grimtex`Sqrt(3)-17*x`}\n\n* ${grimtex`Pow(Mul(2, ConstPi), Sub(s, 1))`}\n`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1246,"value":"grimtex`\"Some string with special chars \\\\, {, }, $, &, #, ^, _, ~, %, \\`, \\\", ;, :, @, !, *, +, ±, =, < ≤, >, ≥ ˘ ƒ é π\"`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1248,"value":"// TODO more latex text escapement...\n// ^ needs more work, literal quotes should be primes within text\n// also, some strings throwing exceptions:\n // grimtex`\"≠\"`\n // grimtex`\"∑ ∫ ∏\"`\ngrimtex`'Single-quoted string input works the same... \\' \" \\` a(b)+c'`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":443,"value":"// have to get parens bits fixed, obviously...\ngrimtex`Formula(Equal(RiemannZeta(s), Mul(Mul(Mul(Mul(2, Pow(Mul(2, ConstPi), Sub(s, 1))), Sin(Div(Mul(ConstPi, s), 2))), GammaFunction(Sub(1, s))), RiemannZeta(Sub(1, s)))))`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":456,"value":"grimtex`Formula(Equal(Totient(n), DivisorSum(MoebiusMu(d) * (n/d), d, n)))`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":469,"value":"grimtex`Element(n, ZZGreaterEqual(0))`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":466,"value":"grimtex`Assumptions(Element(n, ZZGreaterEqual(0)))`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1272,"value":"grimtex`SymbolDefinition(HurwitzZeta, HurwitzZeta(s, a), \"Hurwitz zeta function\")`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":460,"value":"grimtex`DivisorSum(MoebiusMu(d) * (n/d), d, n)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":530,"value":"grimtex`Formula(Equal(StirlingS2(n,k), Div(1,Factorial(k)) * Sum((-1)**i * Binomial(k,i) * (k-i)**n, Tuple(i, 0, k))))`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":488,"value":"grimtex`Formula(Equal(RisingFactorial(x, n), Sum(StirlingCycle(n, k) * x**k, Tuple(k, 0, n))))`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":617,"value":"md`---\n### Latex output\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":836,"value":"// ...","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":834,"value":"// FIXME this ain't even close to right\ngrimtex`Mul(a,b)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":831,"value":"grimtex`Pow(a,b)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":817,"value":"grimtex`Matrix2x2(a,b,c,d)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":819,"value":"grimtex`Matrix2x1(a,b)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":812,"value":"// JacobiTheta","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":810,"value":"// Cases","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":808,"value":"// grimtex`And(a,b,Ellipsis)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":804,"value":"// grimtex`Or(a,b,Ellipsis)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":802,"value":"grimtex`Sqrt(x)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":800,"value":"grimtex`Abs(Ellipsis)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":798,"value":"grimtex`Floor(Ellipsis)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":796,"value":"grimtex`Ceil(Ellipsis)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":794,"value":"grimtex`Tuple(Ellipsis)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":792,"value":"grimtex`Set(Ellipsis)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":790,"value":"grimtex`List(Ellipsis)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":788,"value":"grimtex`Parentheses(Ellipsis)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":785,"value":"grimtex`Brackets(Ellipsis)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":783,"value":"grimtex`Braces(Ellipsis)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":778,"value":"grimtex`Call(a,b,c,Ellipsis)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":774,"value":"grimtex`Subscript(a,b)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":772,"value":"grimtex`Var(a,b,c)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":767,"value":"// Limits...","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":765,"value":"// Std operators...","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":763,"value":"// Derivatives...","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":761,"value":"// Integrals...","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":759,"value":"// Sum, Product","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":745,"value":"grimtex`DivisorSum(a,b,c)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":747,"value":"grimtex`DivisorSum(a,b,c,d)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":749,"value":"grimtex`DivisorProduct(a,b,c)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":752,"value":"grimtex`DivisorProduct(a,b,c,d)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":757,"value":"// PrimeSum, PrimeProduct","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":740,"value":"grimtex`ComplexZeroMultiplicity(a,b,c)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":738,"value":"grimtex`Residue(a,b,c)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":736,"value":"grimtex`CongruentMod(a,b,c)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":734,"value":"grimtex`Odd(a)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":732,"value":"grimtex`Even(a)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":727,"value":"// TODO 2nd arg?\ngrimtex`ZZGreaterEqual(a,b)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":725,"value":"// TODO 2nd arg?\ngrimtex`ZZLessEqual(a,b)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":722,"value":"grimtex`ZZBetween(a,b)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":715,"value":"// TODO\n// grimtex`Interval(a,b)`\n// and: ClosedInterval, OpenInterval, ClosedOpenInterval, OpenClosedInterval","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":712,"value":"grimtex`RealBall(a,b)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":710,"value":"grimtex`BernsteinEllipse(a)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":707,"value":"grimtex`Conjugate(a)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":705,"value":"// TODO what's the signature on this really supposed to be?\ngrimtex`SetBuilder(a,b,c)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":695,"value":"grimtex`Cardinality(a)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":941,"value":"grimtex`Decimal('189.15')`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":691,"value":"grimtex`Decimal('${187e-17}')`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1086,"value":"// integer-like decimals get a radix point appended\ngrimtex`Decimal('189')`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1089,"value":"// same for integer-like mantissa in exponential notation\ngrimtex`Decimal('3e+30')`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":686,"value":"// TODO\n// grimtex`Factorial(7)`\n// grimtex`DoubleFactorial(7)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":534,"value":"grimtex`RisingFactorial(n,k)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":541,"value":"grimtex`FallingFactorial(n,k)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":544,"value":"grimtex`Binomial(n,k)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":547,"value":"grimtex`StirlingCycle(n,k)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":550,"value":"grimtex`StirlingS1(n,k)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":552,"value":"grimtex`StirlingS2(n,k)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":600,"value":"grimtex`LambertW(a,b)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":601,"value":"grimtex`LambertW(a,b,c)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":598,"value":"grimtex`AsymptoticTo(a,b,c,d)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":558,"value":"grimtex`Not(x)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":562,"value":"grimtex`Implies(x,y,z)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":575,"value":"grimtex`Equivalent(x,y,z)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":573,"value":"grimtex`EqualAndElement(a,b,c)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":569,"value":"grimtex`KroneckerDelta(a,b)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":606,"value":"// TODO small variant\ngrimtex`LegendreSymbol(p,q)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":608,"value":"grimtex`JacobiSymbol(p,q)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":609,"value":"grimtex`KroneckerSymbol(p,q)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":604,"value":"grimtex`Lattice(a,b,Ellipsis)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":585,"value":"grimtex`DomainCodomain(a,b)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":582,"value":"grimtex`ModularGroupAction(a,b)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":589,"value":"grimtex`PrimitiveReducedPositiveIntegralBinaryQuadraticForms(a)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":591,"value":"grimtex`HypergeometricUStarRemainder(a,b,c,d)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":670,"value":"grimtex`DirichletCharacter(a,b)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":673,"value":"grimtex`DirichletCharacter(a,b,c)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":668,"value":"grimtex`PrimitiveDirichletCharacters(x)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":665,"value":"grimtex`GaussSum(a,b)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":661,"value":"grimtex`StieltjesGamma(a)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":662,"value":"grimtex`StieltjesGamma(a,b)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":659,"value":"grimtex`FormalPowerSeries(a,b,c)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":657,"value":"grimtex`FormalLaurentSeries(a,b,c)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":655,"value":"grimtex`SeriesCoefficient(a,b,c)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":652,"value":"grimtex`FormalGenerator(a,b)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":651,"value":"grimtex`Spectrum(M)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":648,"value":"grimtex`Det(M)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":643,"value":"grimtex`ForAll(a,b,c)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":642,"value":"grimtex`Exists(a,b)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":640,"value":"grimtex`DiscreteLog(a,b,c)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1542,"value":"grimtex`Equal(a,b,c)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1546,"value":"grimtex`NearestDecimal(a,b)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":991,"value":"md`---\n### Extras...\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":994,"value":"// real tuples...\npygrim`(a,b,c)`.Head()","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1027,"value":"grimtex`(a, b**2, c + d)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1001,"value":"// but no 1-tuples... nor the 0-tuple `()`... these require a `Tuple(x)` wrapper\ngrimtex`(a,)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":987,"value":"grimtex`Matrix((a,b,c),(d,e,f))`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1075,"value":"// TODO this is crap, of course... should probably just sniff for 2d arrays of constant length\n// also need to disambiguate on sequence type and use appropriate bracketing\ngrimtex`Matrix((a,b,c,d),(e,f,g),(h,i),Tuple(j))`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1499,"value":"// list literals\npygrim`[x,(y+z),[[ConstE**(ConstI*ConstPi), Exp(Sin(2*ConstPi))], w**-(1/2)]]`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1502,"value":"grimtex`[x,(y+z),[[ConstE**(ConstI*ConstPi), Exp(Sin(2*ConstPi))], w**-(1/2)]]`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1556,"value":"// TODO parse typescript annotations parser to something like:\n// `x:Integer` to give x ∈ ℤ\n// similarly, allow domain/codomain spec to render something like: `𝑓 : ℝ → ℝ`?\n// or perhaps the notation `ℝ ∋ 𝑥 ↦ 𝑥^2 ∈ ℝ` for anonymous\n// via: https://math.stackexchange.com/questions/651205/regarding-the-notation-f-a-mapsto-b","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1494,"value":"// arrow expression lambdas, because why not?\npygrim`x => x+3`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1551,"value":"grimtex`x=>x+3`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1493,"value":"pygrim`((u,v)=>u**2 + v**4)(x,y)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1529,"value":"// TODO handle subsequent application\ngrimtex`((u,v)=>u**2 + v**4)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1560,"value":"grimtex`Function(x,x+3)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1562,"value":"// TODO handle subsequent application (wrap in parens)...\ngrimtex`Composition(f,g,h)`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1204,"value":"grimtex`SymbolDefinition(HurwitzZeta, HurwitzZeta(s, a), \"Hurwitz zeta function\")`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1464,"value":"md`---\n### Defined symbols\n`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1457,"value":"// TODO iterate over built-in symbols, render raw rep...\n// TODO this should render as ℤ_{≤n}... need proper symbol defs...\ngrimtex`ZZLessEqual`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1468,"value":"grimtex`SymbolDefinition(ZZLessEqual, ZZLessEqual(n), \"Integers less than or equal to n\")`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":860,"value":"md`---\n### ToTeX via standard boxes\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":841,"value":"$38","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":872,"value":"md`\n* Superscript: ${tex`\\left(⬚^⬚\\right)`}\n* Subscript: ${tex`\\left(⬚_⬚\\right)`}\n* Subsuperscript: ${tex`\\left(⬚_⬚^⬚\\right)`}\n* Underscript: ${tex`\\left(\\underset{⬚}{⬚}\\right)`}\n* Overscript: ${tex`\\left(\\overset{⬚}{x}\\right)`}\n* Underoverscript: ${tex`\\left(\\underset{⬚}{\\overset{⬚}{x}}\\right)`}\n`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":864,"value":"units = ({\n Degree: {\n value: pygrim`ConstPi/180`,\n toTex (opts) {\n return raw`^\\circ`\n },\n // toAscii: () => '°'\n // TODO declarative toTex config, allowing a pattern (const string, in this case)\n // lift this into a function upon instantiation of interpretater\n }\n})","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":484,"value":"mutable pygrim_variable_names = ({})","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":479,"value":"$39","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1097,"value":"md`---\n### Fungrim Entry HTML\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1095,"value":"$3a","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1104,"value":"render_Entry(pygrim`Entry(ID(\"04217b\"),\n SymbolDefinition(HurwitzZeta, HurwitzZeta(s, a), \"Hurwitz zeta function\"))\n`, { open: true })","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":248,"value":"md`---\n## Numerical Evaluation\n\nTODO...\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":247,"value":"md`---\n## JSX-esque Interpreter\n\nTODO...\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":103,"value":"md`---\n### Dependencies\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":22,"value":"acorn = require('acorn')","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":25,"value":"immutabletuple = require('https://bundle.run/immutable-tuple@0.4.10')","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":48,"value":"T = immutabletuple.tuple","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":246,"value":"raw = String.raw","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"}],"files":"$W3b","stdlib":"1","titling":"auto"}} 33:"$32:body"