@cortex-js/compute-engine 0.50.1 → 0.51.0

package/dist/types/compute-engine/boxed-expression/expression-map.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 export declare class ExpressionMap<U> implements ExpressionMapInterface<U> {
     readonly _items: Map<Expression, U>;
     constructor(source?: ExpressionMapInterface<U> | readonly (readonly [Expression, U])[]);

package/dist/types/compute-engine/boxed-expression/factor.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 /** Combine rational expressions into a single fraction */
 export declare function together(op: Expression): Expression;
 /**

package/dist/types/compute-engine/boxed-expression/flatten.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 /**
  *
  * Optionally make all the arguments canonical (default).

package/dist/types/compute-engine/boxed-expression/hold.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 /** Apply the function `f` to each operand of the expression `expr`,
  * account for the 'lazy' property of the operator definition:
  *

package/dist/types/compute-engine/boxed-expression/inequality-bounds.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 /**
  * Get inequality bounds for a symbol from the assumption database.
  *

package/dist/types/compute-engine/boxed-expression/init-lazy-refs.d.ts

@@ -1 +1 @@
-/* 0.50.1 */
+/* 0.51.0 */

package/dist/types/compute-engine/boxed-expression/invisible-operator.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 export declare function canonicalInvisibleOperator(ops: ReadonlyArray<Expression>, { engine: ce }: {
     engine: ComputeEngine;
 }): Expression | null;

package/dist/types/compute-engine/boxed-expression/match.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 /**
  * The function attempts to match a subject expression to a
  * [pattern](/compute-engine/guides/patterns-and-rules/).

package/dist/types/compute-engine/boxed-expression/negate.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 export declare function canonicalNegate(expr: Expression): Expression;
 /**
  * Distribute `Negate` (multiply by -1) if expr is a number literal, an

package/dist/types/compute-engine/boxed-expression/numerics.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 import { Decimal } from 'decimal.js';
 import type { Rational } from '../numerics/types';
 import type { Expression, ExpressionInput } from '../global-types';

package/dist/types/compute-engine/boxed-expression/order.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 export type Order = 'lex' | 'dexlex' | 'grevlex' | 'elim';
 import { DEFAULT_COMPLEXITY } from './constants';
 export { DEFAULT_COMPLEXITY };

package/dist/types/compute-engine/boxed-expression/pattern-utils.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
  * Leaf module for wildcard pattern utility functions.
  *
  * These are extracted from boxed-patterns.ts to break circular dependencies:

package/dist/types/compute-engine/boxed-expression/polynomial-degree.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 /**
  * The total degree of an expression is the sum of the
  * positive integer degrees of the factors in the expression:

package/dist/types/compute-engine/boxed-expression/polynomials.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 export { totalDegree, maxDegree, lex, revlex } from './polynomial-degree';
 /**
  * Coefficient of a univariate (single variable) polynomial.

package/dist/types/compute-engine/boxed-expression/predicates.d.ts

@@ -1,2 +1,2 @@
-/* 0.50.1 */
+/* 0.51.0 */
 export declare function isPrime(expr: Expression): boolean | undefined;

package/dist/types/compute-engine/boxed-expression/product.d.ts

@@ -1 +1 @@
-/* 0.50.1 */
+/* 0.51.0 */

package/dist/types/compute-engine/boxed-expression/rules.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 export declare const ConditionParent: {
     boolean: string;
     string: string;

package/dist/types/compute-engine/boxed-expression/serialize.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 import type { IComputeEngine as ComputeEngine, Expression, JsonSerializationOptions } from '../global-types';
 import type { Product as _ProductClass } from './product';
 /** @internal */

package/dist/types/compute-engine/boxed-expression/sgn.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 export declare function sgn(expr: Expression): Sign | undefined;
 /**
  * Sign `s` is > 0.

package/dist/types/compute-engine/boxed-expression/simplify.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 type InternalSimplifyOptions = SimplifyOptions & {
     useVariations: boolean;
 };

package/dist/types/compute-engine/boxed-expression/solve-linear-system.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 /**
  * Solve a system of linear equations.
  *

package/dist/types/compute-engine/boxed-expression/solve.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 export declare const UNIVARIATE_ROOTS: Rule[];
 /**
  * MathJsonExpression is a function of a single variable (`x`) or an Equality

package/dist/types/compute-engine/boxed-expression/trigonometry.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 /** Assuming x in an expression in radians, convert to current angular unit. */
 export declare function radiansToAngle(x: Expression | undefined): Expression | undefined;
 export declare function evalTrig(name: string, op: Expression | undefined): Expression | undefined;

package/dist/types/compute-engine/boxed-expression/type-guards.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 /** Preferred guard for runtime expressions. */
 export declare function isExpression(x: unknown): x is Expression;
 export declare function isNumber(expr: Expression | null | undefined): expr is Expression & NumberLiteralInterface;

package/dist/types/compute-engine/boxed-expression/utils.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 import { Type } from '../../common/type/types';
 import { NumericValue } from '../numeric-value/types';
 /**

package/dist/types/compute-engine/boxed-expression/validate.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 import type { Expression, IComputeEngine as ComputeEngine } from '../global-types';
 /**
  * Check that the number of arguments is as expected.

package/dist/types/compute-engine/collection-utils.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 /** If a collection has fewer than this many elements, eagerly evaluate it.
  *
  * For example, evaluate the Union of two sets with 10 elements each will

package/dist/types/compute-engine/compilation/base-compiler.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 import type { CompileTarget, TargetSource } from './types';
 /**
  * Base compiler class containing language-agnostic compilation logic
@@ -20,6 +20,17 @@ export declare class BaseCompiler {
      * Compile loop constructs (Sum/Product)
      */
     private static compileLoop;
+    /**
+     * Determine at compile time whether an expression produces a complex value.
+     *
+     * Rules:
+     * - Numbers: complex if im !== 0
+     * - Symbols: ImaginaryUnit is complex; others use expr.isReal
+     *   (undefined is treated as real -- assume-real policy)
+     * - Functions: Abs, Arg, Re, Im always return real.
+     *   All others: complex if any operand is complex.
+     */
+    static isComplexValued(expr: Expression): boolean;
     /**
      * Generate a temporary variable name
      */

package/dist/types/compute-engine/compilation/compile-expression.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 import type { Expression, JSSource } from '../global-types';
 import type { CompileTarget, CompilationResult } from './types';
 type CompileExpressionOptions = {

package/dist/types/compute-engine/compilation/glsl-target.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 import type { CompiledFunctions } from './types';
 import { GPUShaderTarget } from './gpu-target';
 /**

package/dist/types/compute-engine/compilation/gpu-target.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 import type { CompileTarget, CompiledOperators, CompiledFunctions, LanguageTarget, CompilationOptions, CompilationResult } from './types';
 /**
  * GPU shader operators shared by GLSL and WGSL.
@@ -13,8 +13,47 @@ export declare const GPU_OPERATORS: CompiledOperators;
  * Both languages share identical built-in math functions. Language-specific
  * functions (inversesqrt naming, mod, vector constructors) are provided
  * by subclass overrides.
+ *
+ * Complex numbers are represented as vec2(re, im). Functions that can
+ * operate on complex values check `BaseCompiler.isComplexValued()` and
+ * dispatch to `_gpu_c*` helper functions from the complex preamble.
  */
 export declare const GPU_FUNCTIONS: CompiledFunctions<Expression>;
+/**
+ * Compile a Matrix expression to GPU-native types when possible.
+ *
+ * Handles two optimizations:
+ * - Column vectors (Nx1): flatten to vecN instead of nested single-element arrays
+ * - Square matrices (NxN, N=2,3,4): use native matN types with column-major transposition
+ *
+ * Falls back to compiling the nested List structure for other shapes.
+ */
+export declare function compileGPUMatrix(args: ReadonlyArray<Expression>, compile: (expr: Expression) => string, vecFn: (n: number) => string, matFn: (n: number) => string, arrayFn: (n: number) => string): string;
+/**
+ * GPU gamma function using Lanczos approximation (g=7, n=9 coefficients).
+ *
+ * Uses reflection formula for z < 0.5 and Lanczos for z >= 0.5.
+ * Valid for both GLSL and WGSL (uses standard math builtins).
+ */
+export declare const GPU_GAMMA_PREAMBLE = "\nfloat _gpu_gamma(float z) {\n  const float PI = 3.14159265358979;\n  if (z < 0.5) {\n    return PI / (sin(PI * z) * _gpu_gamma(1.0 - z));\n  }\n  z -= 1.0;\n  float x = 0.99999999999980993;\n  x += 676.5203681218851 / (z + 1.0);\n  x += -1259.1392167224028 / (z + 2.0);\n  x += 771.32342877765313 / (z + 3.0);\n  x += -176.61502916214059 / (z + 4.0);\n  x += 12.507343278686905 / (z + 5.0);\n  x += -0.13857109526572012 / (z + 6.0);\n  x += 9.9843695780195716e-6 / (z + 7.0);\n  x += 1.5056327351493116e-7 / (z + 8.0);\n  float t = z + 7.5;\n  return sqrt(2.0 * PI) * pow(t, z + 0.5) * exp(-t) * x;\n}\n\nfloat _gpu_gammaln(float z) {\n  // Stirling asymptotic expansion for ln(Gamma(z)), z > 0\n  float z3 = z * z * z;\n  return z * log(z) - z - 0.5 * log(z)\n    + 0.5 * log(2.0 * 3.14159265358979)\n    + 1.0 / (12.0 * z)\n    - 1.0 / (360.0 * z3)\n    + 1.0 / (1260.0 * z3 * z * z);\n}\n";
+/**
+ * GPU error function using Abramowitz & Stegun approximation.
+ * Maximum error: |epsilon(x)| <= 1.5e-7.
+ */
+export declare const GPU_ERF_PREAMBLE = "\nfloat _gpu_erf(float x) {\n  float ax = abs(x);\n  float t = 1.0 / (1.0 + 0.3275911 * ax);\n  float y = ((((1.061405429 * t - 1.453152027) * t + 1.421413741) * t - 0.284496736) * t + 0.254829592) * t;\n  float result = 1.0 - y * exp(-ax * ax);\n  return x < 0.0 ? -result : result;\n}\n\nfloat _gpu_erfinv(float x) {\n  float pi = 3.14159265358979;\n  float x2 = x * x;\n  float x3 = x * x2;\n  float x5 = x3 * x2;\n  float x7 = x5 * x2;\n  float x9 = x7 * x2;\n  return sqrt(pi) * 0.5 * (x + (pi / 12.0) * x3 + (7.0 * pi * pi / 480.0) * x5 + (127.0 * pi * pi * pi / 40320.0) * x7 + (4369.0 * pi * pi * pi * pi / 5806080.0) * x9);\n}\n";
+/**
+ * GPU color space conversion preamble (GLSL syntax).
+ *
+ * Provides sRGB ↔ OKLab ↔ OKLCh conversions, color mixing in OKLCh
+ * with shorter-arc hue interpolation, and APCA contrast calculation.
+ *
+ * WGSL targets must adapt syntax (vec3f, atan2→atan2, etc.).
+ */
+export declare const GPU_COLOR_PREAMBLE_GLSL = "\nfloat _gpu_srgb_to_linear(float c) {\n  if (c <= 0.04045) return c / 12.92;\n  return pow((c + 0.055) / 1.055, 2.4);\n}\n\nfloat _gpu_linear_to_srgb(float c) {\n  if (c <= 0.0031308) return 12.92 * c;\n  return 1.055 * pow(c, 1.0 / 2.4) - 0.055;\n}\n\nvec3 _gpu_srgb_to_oklab(vec3 rgb) {\n  float r = _gpu_srgb_to_linear(rgb.x);\n  float g = _gpu_srgb_to_linear(rgb.y);\n  float b = _gpu_srgb_to_linear(rgb.z);\n  float l_ = pow(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b, 1.0 / 3.0);\n  float m_ = pow(0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b, 1.0 / 3.0);\n  float s_ = pow(0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b, 1.0 / 3.0);\n  return vec3(\n    0.2104542553 * l_ + 0.793617785 * m_ - 0.0040720468 * s_,\n    1.9779984951 * l_ - 2.428592205 * m_ + 0.4505937099 * s_,\n    0.0259040371 * l_ + 0.7827717662 * m_ - 0.808675766 * s_\n  );\n}\n\nvec3 _gpu_oklab_to_srgb(vec3 lab) {\n  float l_ = lab.x + 0.3963377774 * lab.y + 0.2158037573 * lab.z;\n  float m_ = lab.x - 0.1055613458 * lab.y - 0.0638541728 * lab.z;\n  float s_ = lab.x - 0.0894841775 * lab.y - 1.291485548 * lab.z;\n  float l = l_ * l_ * l_;\n  float m = m_ * m_ * m_;\n  float s = s_ * s_ * s_;\n  float r = 4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s;\n  float g = -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s;\n  float b = -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s;\n  return clamp(vec3(_gpu_linear_to_srgb(r), _gpu_linear_to_srgb(g), _gpu_linear_to_srgb(b)), 0.0, 1.0);\n}\n\nvec3 _gpu_oklab_to_oklch(vec3 lab) {\n  float C = length(lab.yz);\n  float H = atan(lab.z, lab.y);\n  return vec3(lab.x, C, H);\n}\n\nvec3 _gpu_oklch_to_oklab(vec3 lch) {\n  return vec3(lch.x, lch.y * cos(lch.z), lch.y * sin(lch.z));\n}\n\nvec3 _gpu_color_mix(vec3 rgb1, vec3 rgb2, float t) {\n  vec3 lch1 = _gpu_oklab_to_oklch(_gpu_srgb_to_oklab(rgb1));\n  vec3 lch2 = _gpu_oklab_to_oklch(_gpu_srgb_to_oklab(rgb2));\n  float L = mix(lch1.x, lch2.x, t);\n  float C = mix(lch1.y, lch2.y, t);\n  float dh = lch2.z - lch1.z;\n  const float PI = 3.14159265359;\n  if (dh > PI) dh -= 2.0 * PI;\n  if (dh < -PI) dh += 2.0 * PI;\n  float H = lch1.z + dh * t;\n  return _gpu_oklab_to_srgb(_gpu_oklch_to_oklab(vec3(L, C, H)));\n}\n\nfloat _gpu_apca(vec3 bg, vec3 fg) {\n  float bgR = _gpu_srgb_to_linear(bg.x);\n  float bgG = _gpu_srgb_to_linear(bg.y);\n  float bgB = _gpu_srgb_to_linear(bg.z);\n  float fgR = _gpu_srgb_to_linear(fg.x);\n  float fgG = _gpu_srgb_to_linear(fg.y);\n  float fgB = _gpu_srgb_to_linear(fg.z);\n  float bgY = 0.2126729 * bgR + 0.7151522 * bgG + 0.0721750 * bgB;\n  float fgY = 0.2126729 * fgR + 0.7151522 * fgG + 0.0721750 * fgB;\n  float bgC = pow(bgY, 0.56);\n  float fgC = pow(fgY, 0.57);\n  float contrast = (bgC > fgC)\n    ? (bgC - fgC) * 1.14\n    : (bgC - fgC) * 1.14;\n  return contrast * 100.0;\n}\n";
+/**
+ * GPU color space conversion preamble (WGSL syntax).
+ */
+export declare const GPU_COLOR_PREAMBLE_WGSL = "\nfn _gpu_srgb_to_linear(c: f32) -> f32 {\n  if (c <= 0.04045) { return c / 12.92; }\n  return pow((c + 0.055) / 1.055, 2.4);\n}\n\nfn _gpu_linear_to_srgb(c: f32) -> f32 {\n  if (c <= 0.0031308) { return 12.92 * c; }\n  return 1.055 * pow(c, 1.0 / 2.4) - 0.055;\n}\n\nfn _gpu_srgb_to_oklab(rgb: vec3f) -> vec3f {\n  let r = _gpu_srgb_to_linear(rgb.x);\n  let g = _gpu_srgb_to_linear(rgb.y);\n  let b = _gpu_srgb_to_linear(rgb.z);\n  let l_ = pow(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b, 1.0 / 3.0);\n  let m_ = pow(0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b, 1.0 / 3.0);\n  let s_ = pow(0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b, 1.0 / 3.0);\n  return vec3f(\n    0.2104542553 * l_ + 0.793617785 * m_ - 0.0040720468 * s_,\n    1.9779984951 * l_ - 2.428592205 * m_ + 0.4505937099 * s_,\n    0.0259040371 * l_ + 0.7827717662 * m_ - 0.808675766 * s_\n  );\n}\n\nfn _gpu_oklab_to_srgb(lab: vec3f) -> vec3f {\n  let l_ = lab.x + 0.3963377774 * lab.y + 0.2158037573 * lab.z;\n  let m_ = lab.x - 0.1055613458 * lab.y - 0.0638541728 * lab.z;\n  let s_ = lab.x - 0.0894841775 * lab.y - 1.291485548 * lab.z;\n  let l = l_ * l_ * l_;\n  let m = m_ * m_ * m_;\n  let s = s_ * s_ * s_;\n  let r = 4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s;\n  let g = -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s;\n  let b = -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s;\n  return clamp(vec3f(_gpu_linear_to_srgb(r), _gpu_linear_to_srgb(g), _gpu_linear_to_srgb(b)), vec3f(0.0), vec3f(1.0));\n}\n\nfn _gpu_oklab_to_oklch(lab: vec3f) -> vec3f {\n  let C = length(lab.yz);\n  let H = atan2(lab.z, lab.y);\n  return vec3f(lab.x, C, H);\n}\n\nfn _gpu_oklch_to_oklab(lch: vec3f) -> vec3f {\n  return vec3f(lch.x, lch.y * cos(lch.z), lch.y * sin(lch.z));\n}\n\nfn _gpu_color_mix(rgb1: vec3f, rgb2: vec3f, t: f32) -> vec3f {\n  let lch1 = _gpu_oklab_to_oklch(_gpu_srgb_to_oklab(rgb1));\n  let lch2 = _gpu_oklab_to_oklch(_gpu_srgb_to_oklab(rgb2));\n  let L = mix(lch1.x, lch2.x, t);\n  let C = mix(lch1.y, lch2.y, t);\n  let PI = 3.14159265359;\n  var dh = lch2.z - lch1.z;\n  if (dh > PI) { dh -= 2.0 * PI; }\n  if (dh < -PI) { dh += 2.0 * PI; }\n  let H = lch1.z + dh * t;\n  return _gpu_oklab_to_srgb(_gpu_oklch_to_oklab(vec3f(L, C, H)));\n}\n\nfn _gpu_apca(bg: vec3f, fg: vec3f) -> f32 {\n  let bgR = _gpu_srgb_to_linear(bg.x);\n  let bgG = _gpu_srgb_to_linear(bg.y);\n  let bgB = _gpu_srgb_to_linear(bg.z);\n  let fgR = _gpu_srgb_to_linear(fg.x);\n  let fgG = _gpu_srgb_to_linear(fg.y);\n  let fgB = _gpu_srgb_to_linear(fg.z);\n  let bgY = 0.2126729 * bgR + 0.7151522 * bgG + 0.0721750 * bgB;\n  let fgY = 0.2126729 * fgR + 0.7151522 * fgG + 0.0721750 * fgB;\n  let bgC = pow(bgY, 0.56);\n  let fgC = pow(fgY, 0.57);\n  let contrast = (bgC - fgC) * 1.14;\n  return contrast * 100.0;\n}\n";
 /**
  * Abstract base class for GPU shader compilation targets.
  *

package/dist/types/compute-engine/compilation/interval-glsl-target.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
  * GLSL interval arithmetic compilation target
  *
  * Compiles mathematical expressions to GLSL code using interval arithmetic

package/dist/types/compute-engine/compilation/interval-javascript-target.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
  * JavaScript interval arithmetic compilation target
  *
  * Compiles mathematical expressions to JavaScript code using interval arithmetic

package/dist/types/compute-engine/compilation/interval-wgsl-target.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
  * WGSL interval arithmetic compilation target
  *
  * Compiles mathematical expressions to WGSL code using interval arithmetic

package/dist/types/compute-engine/compilation/javascript-target.d.ts

@@ -1,6 +1,7 @@
-/* 0.50.1 */
-import { chop, factorial, gcd, lcm, limit } from '../numerics/numeric';
-import { gamma, gammaln } from '../numerics/special-functions';
+/* 0.51.0 */
+import { chop, factorial, factorial2, gcd, lcm, limit } from '../numerics/numeric';
+import { gamma, gammaln, erf, erfc, erfInv, beta, digamma, trigamma, polygamma, zeta, lambertW, besselJ, besselY, besselI, besselK, airyAi, airyBi } from '../numerics/special-functions';
+import { choose } from '../boxed-expression/expand';
 import { interquartileRange, kurtosis, mean, median, mode, populationStandardDeviation, populationVariance, quartiles, skewness, standardDeviation, variance } from '../numerics/statistics';
 import type { CompileTarget, CompiledOperators, CompiledFunctions, LanguageTarget, CompilationOptions, CompilationResult } from './types';
 /**
@@ -8,8 +9,18 @@ import type { CompileTarget, CompiledOperators, CompiledFunctions, LanguageTarge
  */
 export declare class ComputeEngineFunction extends Function {
     SYS: {
+        color(input: string): number[];
+        colorToString(input: string | number[], format?: string): string;
+        colorMix(input1: string | number[], input2: string | number[], ratio?: number): number[];
+        colorContrast(bg: string | number[], fg: string | number[]): number;
+        contrastingColor(bg: string | number[], fg1?: string | number[], fg2?: string | number[]): number[];
+        colorToColorspace(input: string | number[], space: string): number[];
+        colormap(name: string, arg?: number): number[] | number[][];
+        _interpolatePalette(colors: [number, number, number][], t: number): number[];
+        colorFromColorspace(components: number[], space: string): number[];
         chop: typeof chop;
         factorial: typeof factorial;
+        factorial2: typeof factorial2;
         gamma: typeof gamma;
         gcd: typeof gcd;
         integrate: (f: any, a: any, b: any) => number;
@@ -27,6 +38,133 @@ export declare class ComputeEngineFunction extends Function {
         mode: typeof mode;
         quartiles: typeof quartiles;
         interquartileRange: typeof interquartileRange;
+        erf: typeof erf;
+        erfc: typeof erfc;
+        erfInv: typeof erfInv;
+        beta: typeof beta;
+        digamma: typeof digamma;
+        trigamma: typeof trigamma;
+        polygamma: typeof polygamma;
+        zeta: typeof zeta;
+        lambertW: typeof lambertW;
+        besselJ: typeof besselJ;
+        besselY: typeof besselY;
+        besselI: typeof besselI;
+        besselK: typeof besselK;
+        airyAi: typeof airyAi;
+        airyBi: typeof airyBi;
+        binomial: typeof choose;
+        fibonacci: typeof fibonacci;
+        csin: (z: any) => {
+            re: number;
+            im: number;
+        };
+        ccos: (z: any) => {
+            re: number;
+            im: number;
+        };
+        ctan: (z: any) => {
+            re: number;
+            im: number;
+        };
+        casin: (z: any) => {
+            re: number;
+            im: number;
+        };
+        cacos: (z: any) => {
+            re: number;
+            im: number;
+        };
+        catan: (z: any) => {
+            re: number;
+            im: number;
+        };
+        csinh: (z: any) => {
+            re: number;
+            im: number;
+        };
+        ccosh: (z: any) => {
+            re: number;
+            im: number;
+        };
+        ctanh: (z: any) => {
+            re: number;
+            im: number;
+        };
+        csqrt: (z: any) => {
+            re: number;
+            im: number;
+        };
+        cexp: (z: any) => {
+            re: number;
+            im: number;
+        };
+        cln: (z: any) => {
+            re: number;
+            im: number;
+        };
+        cpow: (z: any, w: any) => {
+            re: number;
+            im: number;
+        };
+        ccot: (z: any) => {
+            re: number;
+            im: number;
+        };
+        csec: (z: any) => {
+            re: number;
+            im: number;
+        };
+        ccsc: (z: any) => {
+            re: number;
+            im: number;
+        };
+        ccoth: (z: any) => {
+            re: number;
+            im: number;
+        };
+        csech: (z: any) => {
+            re: number;
+            im: number;
+        };
+        ccsch: (z: any) => {
+            re: number;
+            im: number;
+        };
+        cacot: (z: any) => {
+            re: number;
+            im: number;
+        };
+        casec: (z: any) => {
+            re: number;
+            im: number;
+        };
+        cacsc: (z: any) => {
+            re: number;
+            im: number;
+        };
+        cacoth: (z: any) => {
+            re: number;
+            im: number;
+        };
+        casech: (z: any) => {
+            re: number;
+            im: number;
+        };
+        cacsch: (z: any) => {
+            re: number;
+            im: number;
+        };
+        cabs: (z: any) => any;
+        carg: (z: any) => any;
+        cconj: (z: any) => {
+            re: number;
+            im: number;
+        };
+        cneg: (z: any) => {
+            re: number;
+            im: number;
+        };
     };
     constructor(body: string, preamble?: string);
 }
@@ -35,8 +173,18 @@ export declare class ComputeEngineFunction extends Function {
  */
 export declare class ComputeEngineFunctionLiteral extends Function {
     SYS: {
+        color(input: string): number[];
+        colorToString(input: string | number[], format?: string): string;
+        colorMix(input1: string | number[], input2: string | number[], ratio?: number): number[];
+        colorContrast(bg: string | number[], fg: string | number[]): number;
+        contrastingColor(bg: string | number[], fg1?: string | number[], fg2?: string | number[]): number[];
+        colorToColorspace(input: string | number[], space: string): number[];
+        colormap(name: string, arg?: number): number[] | number[][];
+        _interpolatePalette(colors: [number, number, number][], t: number): number[];
+        colorFromColorspace(components: number[], space: string): number[];
         chop: typeof chop;
         factorial: typeof factorial;
+        factorial2: typeof factorial2;
         gamma: typeof gamma;
         gcd: typeof gcd;
         integrate: (f: any, a: any, b: any) => number;
@@ -54,6 +202,133 @@ export declare class ComputeEngineFunctionLiteral extends Function {
         mode: typeof mode;
         quartiles: typeof quartiles;
         interquartileRange: typeof interquartileRange;
+        erf: typeof erf;
+        erfc: typeof erfc;
+        erfInv: typeof erfInv;
+        beta: typeof beta;
+        digamma: typeof digamma;
+        trigamma: typeof trigamma;
+        polygamma: typeof polygamma;
+        zeta: typeof zeta;
+        lambertW: typeof lambertW;
+        besselJ: typeof besselJ;
+        besselY: typeof besselY;
+        besselI: typeof besselI;
+        besselK: typeof besselK;
+        airyAi: typeof airyAi;
+        airyBi: typeof airyBi;
+        binomial: typeof choose;
+        fibonacci: typeof fibonacci;
+        csin: (z: any) => {
+            re: number;
+            im: number;
+        };
+        ccos: (z: any) => {
+            re: number;
+            im: number;
+        };
+        ctan: (z: any) => {
+            re: number;
+            im: number;
+        };
+        casin: (z: any) => {
+            re: number;
+            im: number;
+        };
+        cacos: (z: any) => {
+            re: number;
+            im: number;
+        };
+        catan: (z: any) => {
+            re: number;
+            im: number;
+        };
+        csinh: (z: any) => {
+            re: number;
+            im: number;
+        };
+        ccosh: (z: any) => {
+            re: number;
+            im: number;
+        };
+        ctanh: (z: any) => {
+            re: number;
+            im: number;
+        };
+        csqrt: (z: any) => {
+            re: number;
+            im: number;
+        };
+        cexp: (z: any) => {
+            re: number;
+            im: number;
+        };
+        cln: (z: any) => {
+            re: number;
+            im: number;
+        };
+        cpow: (z: any, w: any) => {
+            re: number;
+            im: number;
+        };
+        ccot: (z: any) => {
+            re: number;
+            im: number;
+        };
+        csec: (z: any) => {
+            re: number;
+            im: number;
+        };
+        ccsc: (z: any) => {
+            re: number;
+            im: number;
+        };
+        ccoth: (z: any) => {
+            re: number;
+            im: number;
+        };
+        csech: (z: any) => {
+            re: number;
+            im: number;
+        };
+        ccsch: (z: any) => {
+            re: number;
+            im: number;
+        };
+        cacot: (z: any) => {
+            re: number;
+            im: number;
+        };
+        casec: (z: any) => {
+            re: number;
+            im: number;
+        };
+        cacsc: (z: any) => {
+            re: number;
+            im: number;
+        };
+        cacoth: (z: any) => {
+            re: number;
+            im: number;
+        };
+        casech: (z: any) => {
+            re: number;
+            im: number;
+        };
+        cacsch: (z: any) => {
+            re: number;
+            im: number;
+        };
+        cabs: (z: any) => any;
+        carg: (z: any) => any;
+        cconj: (z: any) => {
+            re: number;
+            im: number;
+        };
+        cneg: (z: any) => {
+            re: number;
+            im: number;
+        };
     };
     constructor(body: string, args: string[]);
 }
@@ -66,3 +341,8 @@ export declare class JavaScriptTarget implements LanguageTarget<Expression> {
     createTarget(options?: Partial<CompileTarget<Expression>>): CompileTarget<Expression>;
     compile(expr: Expression, options?: CompilationOptions<Expression>): CompilationResult;
 }
+/**
+ * Compute the nth Fibonacci number using iterative doubling.
+ */
+declare function fibonacci(n: number): number;
+export {};

package/dist/types/compute-engine/compilation/python-target.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 import type { CompileTarget, CompiledOperators, CompiledFunctions, LanguageTarget, CompilationOptions, CompilationResult } from './types';
 /**
  * Python/NumPy language target implementation