Functions — github.com/cortex-js/compute-engine

hub / github.com/cortex-js/compute-engine / functions

Functions5,294 in github.com/cortex-js/compute-engine

⨍ Functions 5,294◇ Types & classes 304

↓ 10 callersFunctionabs

(n: bigint)

src/compute-engine/numerics/diophantine.ts:46

↓ 10 callersMethodadd

* Add this value to another. * Aligns exponents, adds significands. The result is exact.

src/big-decimal/big-decimal.ts:401

↓ 10 callersFunctionasCall

(expr: Json, op: string)

scripts/rubi/extract-rules.ts:64

↓ 10 callersFunctionbesselK

(n: number, x: number)

src/compute-engine/numerics/special-functions.ts:2022

↓ 10 callersFunctionbigGammaP

(ce: ComputeEngine, a: BigNum, x: BigNum)

src/compute-engine/numerics/special-functions.ts:1115

↓ 10 callersFunctionbignum

A bignum case. `args` is the CE-encoded arg list (ints / {num:str}); `mp_args` is the list of mpf values for the reference.

test/compute-engine/nightly/fixtures/gen_kernel_refs.py:55

↓ 10 callersFunctioncheck2F1

( args: (number | unknown[])[], re: number, im: number, tol = 1e-12 )

test/compute-engine/special-functions.test.ts:1267

↓ 10 callersFunctioncmpChain

( args: Json[], ctx: Ctx, cmp: (a: number, b: number) => boolean )

src/compute-engine/rubi/rubi-utils.ts:1043

↓ 10 callersFunctioncompileEntries

( entries: ReadonlyArray<Entry>, declarations: Declarations, overrides: CurationOverrides = {} )

scripts/fungrim/compile-rules.ts:1391

↓ 10 callersFunctioncomponentsTuple

Build a Tuple expression from components, appending alpha when defined.

src/compute-engine/library/colors.ts:283

↓ 10 callersFunctioncontainsHyperbolic

(u: Expression)

src/compute-engine/rubi/rubi-utils.ts:3196

↓ 10 callersMethodcreateTarget

Create a CompileTarget for this language

src/compute-engine/compilation/types.ts:159

↓ 10 callersFunctiondec

(x, n)

benchmarks/gen_cases.py:52

↓ 10 callersFunctiondescription

(c: string | Combinator)

src/point-free-parser/core-combinators.ts:44

↓ 10 callersFunctiondigitsAgree

Number of leading significant digits on which two numeric strings agree.

test/compute-engine/numerics-p2-regressions.test.ts:33

↓ 10 callersFunctiondone

( outcome: Outcome, extra: Partial<ProblemResult> = {} )

scripts/rubi/benchmark.ts:202

↓ 10 callersMethoderrorAt

( value: IR | null, msg: DiagnosticMessage | ((parser: Parser) => DiagnosticMessage), pos: number,

src/point-free-parser/parsers.ts:330

↓ 10 callersFunctionevalN

(expr: any)

test/compute-engine/combinatorics.test.ts:4

↓ 10 callersFunctionevalStr

(ce: ComputeEngine, s: string)

test/compute-engine/latex-syntax/congruence.test.ts:29

↓ 10 callersFunctionevaluateColor

(input: string)

test/compute-engine/colors.test.ts:6

↓ 10 callersFunctionexpectFamilyMatchesBruteForce

* Cross-checks a `'family'` `solvePell` result against the independent * `bruteForcePell` oracle within `[-bound, bound]`.

test/compute-engine/diophantine.test.ts:438

↓ 10 callersFunctionexpectPoly

Assert the truncated polynomial matches an expected LaTeX expression * exactly (structural/symbolic equality of exact coefficients).

test/compute-engine/series.test.ts:45

↓ 10 callersMethodexpm1

exp(this) − 1, accurate for small arguments.

src/big-decimal/transcendentals.ts:62

↓ 10 callersFunctionfactorDifferenceOfSquares

(expr: Expression)

src/compute-engine/boxed-expression/factor.ts:230

↓ 10 callersFunctionfindError

( expr: MathJsonExpression, code: string )

test/compute-engine/latex-syntax/errors.test.ts:51

↓ 10 callersMethodfunctionProperties

* Return the known analytic properties of an operator — poles, zeros, branch * points/cuts, residues, holomorphic/meromorphic domains — drawn from

src/compute-engine/index.ts:1225

↓ 10 callersFunctiongammaQ

(a: number, x: number)

src/compute-engine/numerics/special-functions.ts:244

↓ 10 callersMethodgetInterval

* For an expression representing a domain restriction (a `When` whose * condition is a comparison or `And` of comparisons over `symbol`, or * a

src/compute-engine/types-expression.ts:1773

↓ 10 callersMethodgte

Returns true if this value is greater than or equal to other.

src/big-decimal/big-decimal.ts:389

↓ 10 callersFunctionip

(n: bigint)

test/compute-engine/number-theory.test.ts:508

↓ 10 callersMethodisAtEnd

()

src/common/json5.ts:316

↓ 10 callersFunctionisClean

(s: string)

test/compute-engine/latex-syntax/tier4-structural.test.ts:26

↓ 10 callersFunctionisClean

(s: string)

test/compute-engine/latex-syntax/mathnet-recovery.test.ts:18

↓ 10 callersFunctionisNumber

( expr: Expression | null | undefined )

src/compute-engine/numerics/interval.ts:16

↓ 10 callersFunctionisPrimeBigint

(n: bigint)

src/compute-engine/numerics/primes.ts:171

↓ 10 callersFunctionleafCount

(e: Expression)

src/compute-engine/rubi/rubi-utils.ts:1248

↓ 10 callersMethodmatchAll

(tokens: LatexToken[])

src/compute-engine/latex-syntax/parse.ts:969

↓ 10 callersFunctionmatchOnce

* If `expr` matches pattern, given `substitution` (checks for inconsistency) * return `substitution`, amended with additional matched. Otherwise, `nu

src/compute-engine/boxed-expression/match.ts:114

↓ 10 callersFunctionmpolyToBoxed

(ce: ComputeEngine, poly: MPoly)

src/compute-engine/boxed-expression/multivariate-poly.ts:390

↓ 10 callersFunctionndsolve

( equation: unknown, initialValue: unknown, steps = 100, dependent = 'y', independent = 'x', lower

test/compute-engine/differential-equations.test.ts:7

↓ 10 callersFunctionnv

(data: any)

test/compute-engine/numerics-p2-regressions.test.ts:258

↓ 10 callersFunctionparse

(latex: string)

test/compute-engine/parser-list-range.test.ts:7

↓ 10 callersMethodparse

( latex: string | null, options?: Partial<ParseLatexOptions> & { form?: FormOption; canoni

src/compute-engine/index.ts:1671

↓ 10 callersFunctionparseIntervalBody

* Parse the body of an interval expression and create an Interval MathJSON expression. * * @param body - The parsed body between the delimiters (typ

src/compute-engine/latex-syntax/dictionary/definitions-sets.ts:27

↓ 10 callersFunctionparseSetComprehension

* Determine whether the operands of a `Set` expression describe a * set-builder (comprehension) rather than a literal set. * * A `Set` is a compreh

src/compute-engine/library/collections.ts:2829

↓ 10 callersFunctionparseSizeSwitch

Parse a LaTeX "switch" command that sets a font size for everything * following it in the current group (e.g. `{\large x+y}`).

src/compute-engine/latex-syntax/dictionary/definitions-other.ts:175

↓ 10 callersFunctionpellSatisfies

(D: bigint, N: bigint, x: bigint, y: bigint)

test/compute-engine/diophantine.test.ts:362

↓ 10 callersMethodpolynomialRoots

* Return the roots of this expression treated as a polynomial in `variable`. * Returns `undefined` if the expression is not a polynomial in the giv

src/compute-engine/types-expression.ts:1242

↓ 10 callersFunctionprimeFactors

(n: number)

src/compute-engine/numerics/primes.ts:84

↓ 10 callersFunctionrecanonicalize

(ce: ComputeEngine, e: Expression)

src/compute-engine/rubi/normal-form.ts:231

↓ 10 callersFunctionrnd

()

test/big-decimal/big-decimal.test.ts:1463

↓ 10 callersFunctionroots

(s: string)

test/compute-engine/solve.test.ts:722

↓ 10 callersFunctionserializeExplanation

(latex: string)

test/compute-engine/explain.test.ts:149

↓ 10 callersFunctionspellCheckMessage

(expr: Expression)

src/compute-engine/boxed-expression/validate.ts:656

↓ 10 callersFunctiontoRgb255

* Normalize a color input to an `RgbColor` (0-255 channels). * * Strings are parsed as CSS colors; arrays are interpreted as Oklch * `[L, C, H]` (o

src/compute-engine/compilation/javascript-target.ts:1066

↓ 10 callersFunctiontotalDegree

(expr: Expression)

src/compute-engine/boxed-expression/polynomial-degree.ts:11

↓ 10 callersFunctionunwrapInterval

* Extract the numeric interval {lo, hi} from an IntervalResult. * Handles both plain {lo, hi} and {kind: 'interval', value: {lo, hi}}.

test/compute-engine/compile-sum-product.test.ts:14

↓ 10 callersFunctionvalidate

(pattern: Expression)

test/compute-engine/patterns.test.ts:1108

↓ 10 callersFunctionwdt

(r: IV)

test/compute-engine/interval-glsl-eval.ts:47

↓ 10 callersFunctionwithGuardDigits

* Run `fn` with the global `BigDecimal.precision` raised by `guard` extra * digits, then restore it. The returned value carries the extra correct *

src/compute-engine/numerics/special-functions.ts:448

↓ 9 callersFunctionN

(e: any)

docs/reviews/2026-07-archive/round1-gate.ts:17

↓ 9 callersMethodaddBoundary

(boundary: LatexToken[])

src/compute-engine/latex-syntax/parse.ts:619

↓ 9 callersFunctionbenchmark

Benchmark a function over multiple iterations

benchmarks/python-performance.py:21

↓ 9 callersFunctionbesselI

(n: number, x: number)

src/compute-engine/numerics/special-functions.ts:1948

↓ 9 callersFunctioncanonicalAdd

( ce: ComputeEngine, ops: ReadonlyArray<Expression> )

src/compute-engine/boxed-expression/arithmetic-add.ts:32

↓ 9 callersFunctioncofunctionShift

( ce: ComputeEngine, e: Expression, x: string )

src/compute-engine/rubi/rubi-utils.ts:2560

↓ 9 callersFunctioncollectSymbols

All symbol-position strings appearing in a MathJSON tree.

scripts/fungrim/compile-rules.ts:192

↓ 9 callersFunctioncomposeOuter

Compose an outer coefficient series with an arbitrary inner series (its * constant term is subtracted first so the composition variable vanishes at

src/compute-engine/symbolic/series.ts:166

↓ 9 callersFunctionconstCoeffs

(ce: ComputeEngine, value: Expression, W: number)

src/compute-engine/symbolic/series.ts:92

↓ 9 callersMethoddegreeIn

Degree in variable `i` (the largest exponent of that variable).

src/compute-engine/boxed-expression/multivariate-poly.ts:170

↓ 9 callersMethodfactors

* Return the multiplicative factors of this expression as a flat array. * * This is a structural decomposition — it does not perform algebraic

src/compute-engine/types-expression.ts:1188

↓ 9 callersFunctionfloorDiv

Floor division `⌊a/b⌋` (SymPy's `//`), for `b ≠ 0`.

src/compute-engine/numerics/diophantine.ts:65

↓ 9 callersFunctionfromFixedPoint

* Convert a base-2 fixed-point bigint (value = fp / 2^bits) back to a * BigDecimal, rounding to `targetPrecision` significant decimal digits.

src/big-decimal/transcendentals.ts:139

↓ 9 callersFunctiongammaRatioC

* Product of Γ over `num` divided by the product of Γ over `den`, with * explicit pole handling: a Γ-pole (non-positive integer argument) in the * d

src/compute-engine/numerics/numeric-complex.ts:610

↓ 9 callersFunctiongammaReport

( label: string, z: string, refFn: (prec: number) => string )

test/big-decimal/precision-comparison.test.ts:398

↓ 9 callersFunctiongcd

(a: number, b: number)

src/compute-engine/numerics/numeric.ts:166

↓ 9 callersFunctiongcd

(a: bigint, b: bigint)

src/compute-engine/numerics/numeric-bigint.ts:4

↓ 9 callersMethodgetRuleSet

( id?: 'harmonization' | 'solve-univariate' | 'standard-simplification' )

src/compute-engine/types-engine.ts:372

↓ 9 callersMethodgetSymbolType

(id: MathJsonSymbol)

src/compute-engine/latex-syntax/types.ts:869

↓ 9 callersFunctionisZero

()

src/compute-engine/tensor/tensors.ts:306

↓ 9 callersFunctionlConst

(ce: ComputeEngine, value: Expression, W: number)

src/compute-engine/symbolic/series.ts:551

↓ 9 callersFunctionnum_str

(s)

test/compute-engine/nightly/fixtures/gen_kernel_refs.py:37

↓ 9 callersFunctionnumericBoundValue

The numeric (finite, real) value of a bound expression, or undefined.

src/compute-engine/assume.ts:1056

↓ 9 callersMethodparseArguments

* Parse an argument list, for example: `(12, x+1)` or `\left(x\right)` * * - 'enclosure' : will look for arguments inside an enclosure * (

src/compute-engine/latex-syntax/types.ts:1053

↓ 9 callersFunctionparseCells

( parser: Parser )

src/compute-engine/latex-syntax/dictionary/definitions-linear-algebra.ts:452

↓ 9 callersFunctionparseColumnFormat

(parser: Parser, optional = true)

src/compute-engine/latex-syntax/dictionary/definitions-linear-algebra.ts:467

↓ 9 callersMethodparseExpression

* Parse an expression: * * <expression> ::= * | <primary> * | <prefix-op> <primary> * | <primary> <infix-op> <expression> * *

src/compute-engine/latex-syntax/parse.ts:2954

↓ 9 callersFunctionparsePrime

( parser: Parser, lhs: MathJsonExpression, order: number )

src/compute-engine/latex-syntax/dictionary/definitions-core.ts:2442

↓ 9 callersMethodparseStringGroup

* Some LaTeX commands have arguments that are not interpreted as * expressions, but as strings. For example, `\begin{array}{ccc}` (both * `array

src/compute-engine/latex-syntax/types.ts:1023

↓ 9 callersFunctionposQ

Rubi PosQ[u] := PosAux[TogetherSimplify[u]] — the Together step is * semantic, not cosmetic: PosAux[a − bc/d] has First = a (positive form) * while

src/compute-engine/rubi/rubi-utils.ts:1122

↓ 9 callersFunctionrep

(d: BigDecimal)

test/big-decimal/big-decimal.test.ts:6

↓ 9 callersFunctionreplace

( expr: Expression, rules: Rule | (Rule | BoxedRule)[] | BoxedRuleSet, options?: Partial<ReplaceOptions>

src/compute-engine/boxed-expression/rules.ts:1249

↓ 9 callersFunctionsame

(a: unknown, b: string)

test/compute-engine/multivariate-gcd.test.ts:13

↓ 9 callersFunctionsameNumerically

(a: Expression, b: Expression)

test/compute-engine/rubi-utils.test.ts:305

↓ 9 callersMethodsymbolInfo

* Return introspection metadata for a symbol (value definition) in the * current scope chain. * * - `kind: 'constant'` when the symbol is a C

src/compute-engine/types-engine.ts:688

↓ 9 callersFunctiontally

(sel: (r: (typeof rows)[number]) => Verdict, pred: (c: Case) => boolean)

benchmarks/audit/solve.ts:197

↓ 9 callersFunctiontoFixedPoint

* Convert a BigDecimal to a base-2 fixed-point bigint. * * Returns [fp, bits] where fp / 2^bits represents the same value. * `precision` is the req

src/big-decimal/transcendentals.ts:125

↓ 9 callersMethodtoSignedFunction

* For a relation expression (`Equal`, `Less`, `Greater`, `LessEqual`, * `GreaterEqual`, `NotEqual`), return the "signed function" form * useful

src/compute-engine/types-expression.ts:1751

↓ 9 callersFunctiontokensToString

( tokens: Token | Token[] | [Token[] | Token][] )

src/compute-engine/latex-syntax/tokenizer.ts:454

↓ 9 callersFunctiontuples

Evaluate a multi-variable `Solve` and return its tuples as arrays of numbers * (each coordinate numericized). Throws if the result is not a `List` o

test/compute-engine/solve-diophantine.test.ts:12

← previous next →601–700 of 5,294, ranked by callers