@cortex-js/compute-engine 0.50.2 → 0.51.1

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

@@ -1,2 +1,2 @@
-/* 0.50.2 */
+/* 0.51.1 */
 export declare function canonicalForm(expr: Expression, forms: CanonicalOptions, scope?: Scope): Expression;

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

@@ -1,4 +1,4 @@
-/* 0.50.2 */
+/* 0.51.1 */
 import type { expand as _ExpandFn } from './expand';
 /** @internal */
 export declare function _setExpand(fn: typeof _ExpandFn): void;

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

@@ -1,4 +1,4 @@
-/* 0.50.2 */
+/* 0.51.1 */
  * Leaf module for shared constants used across boxed-expression modules.
  * No imports from sibling modules to avoid circular dependencies.
  */

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

@@ -1,4 +1,4 @@
-/* 0.50.2 */
+/* 0.51.1 */
 export declare function choose(n: number, k: number): number;
 /** Attempt to transform the expression (h, ops) into a sum */
 export declare function expandFunction(ce: ComputeEngine, h: string, ops: ReadonlyArray<Expression>): Expression | null;

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

@@ -1,4 +1,4 @@
-/* 0.50.2 */
+/* 0.51.1 */
 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.2 */
+/* 0.51.1 */
 /** 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.2 */
+/* 0.51.1 */
 /**
  *
  * Optionally make all the arguments canonical (default).

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

@@ -1,4 +1,4 @@
-/* 0.50.2 */
+/* 0.51.1 */
 /** 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.2 */
+/* 0.51.1 */
 /**
  * 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.2 */
+/* 0.51.1 */

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

@@ -1,4 +1,4 @@
-/* 0.50.2 */
+/* 0.51.1 */
 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.2 */
+/* 0.51.1 */
 /**
  * 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.2 */
+/* 0.51.1 */
 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.2 */
+/* 0.51.1 */
 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.2 */
+/* 0.51.1 */
 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.2 */
+/* 0.51.1 */
  * 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.2 */
+/* 0.51.1 */
 /**
  * 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.2 */
+/* 0.51.1 */
 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.2 */
+/* 0.51.1 */
 export declare function isPrime(expr: Expression): boolean | undefined;

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

@@ -1 +1 @@
-/* 0.50.2 */
+/* 0.51.1 */

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

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

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

@@ -1,4 +1,4 @@
-/* 0.50.2 */
+/* 0.51.1 */
 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.2 */
+/* 0.51.1 */
 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.2 */
+/* 0.51.1 */
 type InternalSimplifyOptions = SimplifyOptions & {
     useVariations: boolean;
 };

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

@@ -1,4 +1,4 @@
-/* 0.50.2 */
+/* 0.51.1 */
 /**
  * Solve a system of linear equations.
  *

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

@@ -1,4 +1,4 @@
-/* 0.50.2 */
+/* 0.51.1 */
 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.2 */
+/* 0.51.1 */
 /** 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.2 */
+/* 0.51.1 */
 /** 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.2 */
+/* 0.51.1 */
 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.2 */
+/* 0.51.1 */
 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.2 */
+/* 0.51.1 */
 /** 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.2 */
+/* 0.51.1 */
 import type { CompileTarget, TargetSource } from './types';
 /**
  * Base compiler class containing language-agnostic compilation logic
@@ -16,10 +16,46 @@ export declare class BaseCompiler {
      * Compile a block expression
      */
     private static compileBlock;
+    /**
+     * Compile a Loop expression with Element(index, Range(lo, hi)) indexing.
+     * Generates: (() => { for (let i = lo; i <= hi; i++) { body } })()
+     *
+     * The loop counter is always a raw number. For targets that wrap numeric
+     * values (e.g. interval-js wraps with `_IA.point()`), references to the
+     * loop index inside the body are wrapped via `target.number`.
+     */
+    private static compileForLoop;
+    /**
+     * Compile a loop body expression as statements (not wrapped in IIFE).
+     * Handles Break, Continue, Return as statements, and If as if-else when
+     * branches contain control flow.
+     */
+    private static compileLoopBody;
+    /**
+     * Create a target that compiles conditions as plain JS booleans.
+     * Used inside `compileLoopBody` so that `if (cond)` gets a real boolean,
+     * not an interval result object (which would always be truthy).
+     *
+     * Overrides comparison and logical operators to use plain JS, and
+     * numeric values/variables to use raw numbers (the loop counter is
+     * already a plain number).
+     */
+    private static scalarConditionTarget;
     /**
      * 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.2 */
+/* 0.51.1 */
 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.2 */
+/* 0.51.1 */
 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.2 */
+/* 0.51.1 */
 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.2 */
+/* 0.51.1 */
  * 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.2 */
+/* 0.51.1 */
  * JavaScript interval arithmetic compilation target
  *
  * Compiles mathematical expressions to JavaScript code using interval arithmetic
@@ -54,7 +54,10 @@ export declare class ComputeEngineIntervalFunction extends Function {
         max: typeof import("../interval").max;
         mod: typeof import("../interval").mod;
         remainder: typeof import("../interval").remainder;
+        heaviside: typeof import("../interval").heaviside;
         sign: typeof import("../interval").sign;
+        gamma: typeof import("../interval").gamma;
+        gammaln: typeof import("../interval").gammaln;
         sin: typeof import("../interval").sin;
         cos: typeof import("../interval").cos;
         tan: typeof import("../interval").tan;
@@ -80,6 +83,9 @@ export declare class ComputeEngineIntervalFunction extends Function {
         acoth: typeof import("../interval").acoth;
         acsch: typeof import("../interval").acsch;
         asech: typeof import("../interval").asech;
+        sinc: typeof import("../interval").sinc;
+        fresnelS: typeof import("../interval").fresnelS;
+        fresnelC: typeof import("../interval").fresnelC;
         less: typeof import("../interval").less;
         lessEqual: typeof import("../interval").lessEqual;
         greater: typeof import("../interval").greater;

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

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