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

↓ 3,943 callersMethodexpr

( expr: NumericValue | ExpressionInput, options?: { form?: FormOption; scope?: Scope;

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

↓ 2,943 callersMethodparse

( name: string, parser: Parser | string, url?: string )

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

↓ 2,720 callersMethodevaluate

* Return the value of the canonical form of this expression. * * A pure expression always returns the same value (provided that it * remains

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

↓ 2,043 callersMethodtoString

* Return an ASCIIMath representation of the expression. This string is * suitable to be output to the console for debugging, for example. * *

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

↓ 1,389 callersFunctionisFunction

( expr: Expression | null | undefined, operator?: string )

src/compute-engine/boxed-expression/type-guards.ts:47

↓ 1,315 callersMethodmul

Multiplication

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

↓ 1,283 callersMethodisSame

Fast exact structural/symbolic equality check. * * Returns `true` if the expression is structurally identical to `rhs`. * For symbols with va

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

↓ 1,210 callersMethodnumber

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

↓ 1,194 callersMethodmap

* Recursively replace all the subexpressions in the expression as indicated. * * To remove a subexpression, return an empty `["Sequence"]` expre

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

↓ 953 callersMethodbox

@deprecated Use `expr()` instead.

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

↓ 916 callersMethodfunction

( name: string, ops: ReadonlyArray<ExpressionInput>, options?: { metadata?: Metadata;

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

↓ 832 callersMethodN

Return a numeric approximation of the canonical form of this expression. * * Any necessary calculations, including on decimal numbers (non-integ

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

↓ 797 callersMethodabs

Absolute value

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

↓ 794 callersMethodlog

Logarithm with specified base.

src/big-decimal/transcendentals.ts:36

↓ 783 callersMethod_fn

* This is a primitive to create a boxed function. * * In general, consider using `ce.expr()` or `ce.function()` or * `canonicalXXX()` instead

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

↓ 727 callersMethodadd

(other: Tensor<DT> | DataTypeMap[DT])

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

↓ 715 callersMethoddiv

Division

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

↓ 709 callersFunctioncompile

( expr: Expression, options: CompilationOptions<Expression> = {} )

src/compute-engine/compilation/gpu-target.ts:3383

↓ 616 callersMethodsimplify

* Return a simpler form of this expression. * * A series of rewriting rules are applied repeatedly, until no more rules * apply. * * Th

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

↓ 608 callersMethodsub

Subtraction

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

↓ 505 callersFunctioncompile

( expr: Expression, options?: CompileExpressionOptions<T> )

src/compute-engine/compilation/compile-expression.ts:59

↓ 493 callersMethodhas

* True if the expression includes a symbol `v` or a function operator `v`. * * :::info[Note] * Applicable to canonical and non-canonical expr

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

↓ 467 callersMethodslice

(index: number)

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

↓ 458 callersMethodcompile

Compile an expression to this language

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

↓ 441 callersFunctioncheckSimplify

* Helper: parse input, simplify, check semantic equality with expected. * On failure, reports LaTeX for readability.

test/compute-engine/simplify.test.ts:11

↓ 435 callersMethoddeclare

(symbols: { [id: MathJsonSymbol]: Type | TypeString | Partial<SymbolDefinition>; })

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

↓ 429 callersMethodpow

Power

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

↓ 406 callersFunctioncheckSimplify

* Helper: parse input, simplify, check semantic equality with expected. * On failure, reports LaTeX for readability.

test/compute-engine/simplify-noskip.test.ts:11

↓ 388 callersFunctionisNumber

( expr: Expression | null | undefined )

src/compute-engine/boxed-expression/type-guards.ts:30

↓ 387 callersMethodget

If this is a keyed collection (map, record, tuple), return the value of * the corresponding key. * * If `key` is a `Expression`, it should be

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

↓ 378 callersMethodsymbol

( sym: string, options?: { canonical?: CanonicalOptions; metadata?: Metadata } )

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

↓ 365 callersMethodneg

Negate (additive inverse)

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

↓ 344 callersFunctionisSymbol

( expr: Expression | null | undefined, name?: string )

src/compute-engine/boxed-expression/type-guards.ts:36

↓ 335 callersFunctionsym

(expr: Expression | null | undefined)

src/compute-engine/boxed-expression/type-guards.ts:105

↓ 300 callersFunctionoperand

( expr: MathJsonExpression | null, n: 1 | 2 | 3 )

src/math-json/utils.ts:160

↓ 287 callersMethodsubs

* Replace all the symbols in the expression as indicated. * * Note the same effect can be achieved with `this.replace()`, but * using `this.s

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

↓ 271 callersMethodreplace

* Transform the expression by applying one or more replacement rules: * * - If the expression matches the `match` pattern and the `condition`

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

↓ 266 callersMethodassume

(predicate: Expression | string)

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

↓ 255 callersMethodisInteger

()

src/compute-engine/boxed-expression/boxed-symbol.ts:666

↓ 249 callersMethoderror

* Return an error expression with the specified code and arguments. * * The returned `Error` expression includes `sourceOffsets` metadata with

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

↓ 243 callersMethodisFinite

()

src/compute-engine/boxed-expression/boxed-symbol.ts:618

↓ 233 callersFunctionlatex

(expr: Expression | undefined | null)

test/utils.ts:243

↓ 232 callersMethodmatch

If the next token matches the target advance and return true. Otherwise * return false

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

↓ 228 callersMethodmatches

(t: BoxedType)

src/compute-engine/types-kernel-evaluation.ts:26

↓ 226 callersMethodassign

(ids: { [id: MathJsonSymbol]: AssignValue })

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

↓ 212 callersFunctioncheck

(latex: string, variants?: Array<ExprVariant>)

test/utils.ts:239

↓ 208 callersMethodpushScope

(scope?: Scope, name?: string)

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

↓ 205 callersMethodserialize

( expr: import('../math-json/types').MathJsonExpression, options?: Record<string, unknown> )

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

↓ 204 callersMethodpopScope

()

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

↓ 199 callersMethodexp

Exponential: e^this.

src/big-decimal/transcendentals.ts:32

↓ 199 callersMethodsolve

* If this is an equation, solve the equation for the variables in vars. * Otherwise, solve the equation `this = 0` for the variables in vars. *

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

↓ 193 callersMethodset

(expr: Expr, value: U)

src/compute-engine/types-kernel-evaluation.ts:41

↓ 186 callersFunctionvalidCortex

(s: string)

test/utils.ts:331

↓ 183 callersMethodsqrt

Square root

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

↓ 182 callersMethodtoFixed

* Format with a fixed number of decimal places. * * Rounds to the specified number of digits after the decimal point * using round-half-to-ev

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

↓ 180 callersMethod_numericValue

@internal

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

↓ 179 callersFunctioncheck

(s: string | Expression)

test/compute-engine/ascii-math.test.ts:6

↓ 178 callersFunctionoperator

( expr: MathJsonExpression | null | undefined )

src/math-json/utils.ts:134

↓ 178 callersFunctionsimplify

(latex: string)

test/utils.ts:120

↓ 165 callersFunctionparseType

( s: TypeString | Type | undefined, typeResolver?: TypeResolver )

src/common/type/parse.ts:43

↓ 162 callersFunctionisSubtype

( lhs: Type | TypeString, rhs: Type | TypeString )

src/common/type/subtype.ts:345

↓ 158 callersFunctionexpectApprox

( expr: any, expected: number, tolerance = 1e-10 )

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

↓ 158 callersMethodsin

Sine. Returns NaN for NaN/Infinity inputs.

src/big-decimal/transcendentals.ts:38

↓ 152 callersFunctionevaluate

(expr: string)

test/compute-engine/calculus.test.ts:3

↓ 149 callersMethodisZero

(x: T)

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

↓ 149 callersMethodvalueOf

* * Return a JavaScript primitive value for the expression, based on * `Object.valueOf()`. * * This method is intended to make it easier t

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

↓ 147 callersMethodisNaN

True when this value represents NaN.

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

↓ 141 callersMethodhas

(name: string)

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

↓ 132 callersMethodeq

* Returns true if this value equals other. * NaN === NaN → false (standard NaN semantics).

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

↓ 132 callersMethodverify

(query: Expression | string)

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

↓ 130 callersFunctioncheckJson

( inExpr: ExpressionInput | null, variants?: Array<ExprVariant> )

test/utils.ts:151

↓ 128 callersMethodisFinite

True when the exponent is finite (not NaN, not +/-Infinity).

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

↓ 127 callersFunctionserializeCortex

( expr: MathJsonExpression, options?: FormattingOptions & { fancySymbols?: boolean; } )

src/cortex/serialize-cortex.ts:67

↓ 126 callersFunctionmatch

( pattern: ExpressionInput, expr: Expression | MathJsonExpression, options?: PatternMatchOptions )

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

↓ 123 callersFunctionbuild

(json: Json, ctx: Ctx)

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

↓ 123 callersFunctionfn

(h: string, a: Expression[])

src/compute-engine/library/distributions.ts:273

↓ 122 callersFunctionbox

(expr: any)

test/compute-engine/logic.test.ts:3

↓ 122 callersMethodcontains

* If this is a collection, return true if the `rhs` expression is in the * collection. * * Return `undefined` if the membership cannot be det

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

↓ 122 callersMethodtoNumber

Convert to a JavaScript number. May lose precision for large values.

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

↓ 120 callersMethodat

(...indices: number[])

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

↓ 120 callersMethodlt

Returns true if this value is strictly less than other.

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

↓ 119 callersMethodsqrt

Square root. Returns NaN for negative values.

src/big-decimal/transcendentals.ts:28

↓ 115 callersMethodcos

Cosine. Returns NaN for NaN/Infinity inputs.

src/big-decimal/transcendentals.ts:40

↓ 115 callersMethodkeys

()

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

↓ 114 callersMethodisComplexValued

* Determine at compile time whether an expression produces a complex value. * * Uses the expression's declared type (from operator signatures) w

src/compute-engine/compilation/base-compiler.ts:1106

↓ 113 callersFunctionexpr

(s: string)

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

↓ 113 callersMethodtoPrecision

* Round to n significant digits, returning a new BigDecimal. * Uses round-half-to-even for tie-breaking. * If the value already has n or fewer s

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

↓ 111 callersMethodtoLatex

* Return a LaTeX representation of this expression with custom * serialization options. * * Numeric values are rounded to `ce.precision` sign

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

↓ 110 callersMethodisNaN

()

src/compute-engine/numeric-value/big-numeric-value.ts:149

↓ 110 callersFunctionw

(s = '')

benchmarks/report.mjs:343

↓ 109 callersMethodis

* Smart equality check: structural first, then numeric evaluation fallback. * Symmetric: `a.is(b)` always equals `b.is(a)`. * * First tries a

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

↓ 109 callersMethodisEqual

Mathematical equality (strong equality), that is the value * of this expression and the value of `other` are numerically equal. * * Both expr

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

↓ 107 callersMethodeach

* If this is a collection, return an iterator over the elements of the * collection. * * ```js * const expr = ce.parse('[1, 2, 3, 4]');

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

↓ 106 callersFunctionoperands

( expr: MathJsonExpression | null | undefined )

src/math-json/utils.ts:150

↓ 105 callersFunctionevalStr

(expr: any[])

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

↓ 104 callersMethodln

Natural logarithm. Returns NaN for negative values, -Infinity for zero.

src/big-decimal/transcendentals.ts:34

↓ 102 callersFunctionok

(value: Interval)

src/compute-engine/interval/util.ts:14

↓ 101 callersFunctionprint

()

src/compute-engine/numeric-value/types.ts:177

↓ 93 callersFunctionjoinLatex

(segments: Iterable<string>)

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

↓ 92 callersFunctionisEquivalent

(a: string | Expression, b: string)

test/compute-engine/benchmarks/grudnitski.test.ts:5

next →1–100 of 5,294, ranked by callers