@cortex-js/compute-engine 0.51.0 → 0.51.1

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

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

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

@@ -1 +1 @@
-/* 0.51.0 */
+/* 0.51.1 */

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

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 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.51.0 */
+/* 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.51.0 */
+/* 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.51.0 */
+/* 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.51.0 */
+/* 0.51.1 */
 /**
  * Solve a system of linear equations.
  *

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

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 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.51.0 */
+/* 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.51.0 */
+/* 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.51.0 */
+/* 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.51.0 */
+/* 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.51.0 */
+/* 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.51.0 */
+/* 0.51.1 */
 import type { CompileTarget, TargetSource } from './types';
 /**
  * Base compiler class containing language-agnostic compilation logic
@@ -16,6 +16,31 @@ 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)
      */

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

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 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.51.0 */
+/* 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.51.0 */
+/* 0.51.1 */
 import type { CompileTarget, CompiledOperators, CompiledFunctions, LanguageTarget, CompilationOptions, CompilationResult } from './types';
 /**
  * GPU shader operators shared by GLSL and WGSL.

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

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 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.51.0 */
+/* 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.51.0 */
+/* 0.51.1 */
  * 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,6 @@
-/* 0.51.0 */
+/* 0.51.1 */
 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 { gamma, gammaln, erf, erfc, erfInv, beta, digamma, trigamma, polygamma, zeta, lambertW, besselJ, besselY, besselI, besselK, airyAi, airyBi, fresnelS, fresnelC, sinc } 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';
@@ -23,6 +23,7 @@ export declare class ComputeEngineFunction extends Function {
         factorial2: typeof factorial2;
         gamma: typeof gamma;
         gcd: typeof gcd;
+        heaviside: (x: number) => 0 | 1 | 0.5;
         integrate: (f: any, a: any, b: any) => number;
         lcm: typeof lcm;
         lngamma: typeof gammaln;
@@ -53,6 +54,9 @@ export declare class ComputeEngineFunction extends Function {
         besselK: typeof besselK;
         airyAi: typeof airyAi;
         airyBi: typeof airyBi;
+        sinc: typeof sinc;
+        fresnelS: typeof fresnelS;
+        fresnelC: typeof fresnelC;
         binomial: typeof choose;
         fibonacci: typeof fibonacci;
         csin: (z: any) => {
@@ -187,6 +191,7 @@ export declare class ComputeEngineFunctionLiteral extends Function {
         factorial2: typeof factorial2;
         gamma: typeof gamma;
         gcd: typeof gcd;
+        heaviside: (x: number) => 0 | 1 | 0.5;
         integrate: (f: any, a: any, b: any) => number;
         lcm: typeof lcm;
         lngamma: typeof gammaln;
@@ -217,6 +222,9 @@ export declare class ComputeEngineFunctionLiteral extends Function {
         besselK: typeof besselK;
         airyAi: typeof airyAi;
         airyBi: typeof airyBi;
+        sinc: typeof sinc;
+        fresnelS: typeof fresnelS;
+        fresnelC: typeof fresnelC;
         binomial: typeof choose;
         fibonacci: typeof fibonacci;
         csin: (z: any) => {

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

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

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

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 0.51.1 */
 /**
  * Source code in the target language
  */
@@ -132,6 +132,15 @@ export interface CompilationOptions<Expr = unknown> {
     imports?: unknown[];
     /** Additional preamble code */
     preamble?: string;
+    /**
+     * When true, complex results (`{ re, im }`) are converted to real numbers:
+     * - If the imaginary part is zero, the real part is returned
+     * - Otherwise, `NaN` is returned
+     *
+     * This avoids object allocations for callers that only need real-valued
+     * results (e.g., plotting).
+     */
+    realOnly?: boolean;
 }
 /**
  * Result of compiling an expression
@@ -154,11 +163,20 @@ export interface CompilationResult {
      * target's `compileShaderFunction()` method directly.
      */
     preamble?: string;
-    /** Executable function (present for JS-executable targets only) */
-    run?: (...args: (number | {
-        re: number;
-        im: number;
-    })[]) => number | {
+    /**
+     * Executable function (present for JS-executable targets only).
+     *
+     * For plain expressions, call with a vars object:
+     * ```typescript
+     * result.run({ x: 0.5 })
+     * ```
+     *
+     * For `Function` (lambda) expressions, call with positional arguments:
+     * ```typescript
+     * result.run(0.5)
+     * ```
+     */
+    run?: (...args: unknown[]) => number | {
         re: number;
         im: number;
     };

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

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

package/dist/types/compute-engine/cost-function.d.ts

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 0.51.1 */
 /**
  * The default cost function, used to determine if a new expression is simpler
  * than the old one.

package/dist/types/compute-engine/engine-assumptions.d.ts

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 0.51.1 */
 import type { MathJsonSymbol } from '../math-json/types';
 export declare function ask(ce: IComputeEngine, pattern: Expression): BoxedSubstitution[];
 export declare function verify(ce: IComputeEngine, query: Expression): boolean | undefined;

package/dist/types/compute-engine/engine-cache.d.ts

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 0.51.1 */
     private _entries;
     getOrBuild<T>(cacheName: string, build: () => T, purge?: (t: T) => T | undefined): T;
     invalidate(cacheName: string): void;

package/dist/types/compute-engine/engine-common-symbols.d.ts

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 0.51.1 */
 export type CommonSymbolTable = {
     [symbol: string]: null | Expression;
 };

package/dist/types/compute-engine/engine-compilation-targets.d.ts

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 0.51.1 */
 import type { LanguageTarget } from './compilation/types';
 /**
  * Internal registry for compilation targets.

package/dist/types/compute-engine/engine-configuration-lifecycle.d.ts

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 0.51.1 */
 type ResetHooks = {
     refreshNumericConstants: () => void;
     resetCommonSymbols: () => void;

package/dist/types/compute-engine/engine-declarations.d.ts

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 0.51.1 */
 import { BoxedType } from '../common/type/boxed-type';
 import type { MathJsonSymbol } from '../math-json/types';
 import type { ValueDefinition, OperatorDefinition, AssignValue, Expression, BoxedDefinition, SymbolDefinition, IComputeEngine, Scope } from './global-types';

package/dist/types/compute-engine/engine-expression-entrypoints.d.ts

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 0.51.1 */
 import { Decimal } from 'decimal.js';
 import type { MathJsonNumberObject, MathJsonSymbol } from '../math-json/types';
 import { NumericValue } from './numeric-value/types';

package/dist/types/compute-engine/engine-extension-contracts.d.ts

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 0.51.1 */
 import type { LanguageTarget, CompilationOptions } from './compilation/types';
 export declare function assertCompilationTargetName(name: unknown): string;
 export declare function assertLibraryName(name: unknown): string;

package/dist/types/compute-engine/engine-latex-dictionary-state.d.ts

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 0.51.1 */
 import type { LatexDictionaryEntry } from './latex-syntax/types';
 type DefaultDictionaryProvider = () => Readonly<LatexDictionaryEntry[]>;
 export declare class EngineLatexDictionaryState {

package/dist/types/compute-engine/engine-library-bootstrap.d.ts

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 0.51.1 */
 import type { LatexDictionaryEntry, LibraryCategory } from './latex-syntax/types';
 export declare function resolveBootstrapLibraries(libraries?: readonly (string | LibraryDefinition)[]): LibraryDefinition[];
 export declare function loadLibraryDefinitions(engine: ComputeEngine, libraries: readonly LibraryDefinition[]): void;

package/dist/types/compute-engine/engine-numeric-configuration.d.ts

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 0.51.1 */
 import type { AngularUnit } from './types-definitions';
 export declare class EngineNumericConfiguration {
     private _bignum;

package/dist/types/compute-engine/engine-parse-entrypoint.d.ts

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 0.51.1 */
 import type { LatexString, ParseLatexOptions } from './latex-syntax/types';
 import type { FormOption } from './types-serialization';
 export type ParseEntrypointOptions = Partial<ParseLatexOptions> & {

package/dist/types/compute-engine/engine-runtime-state.d.ts

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 0.51.1 */
     private _timeLimit;
     private _iterationLimit;
     private _recursionLimit;

package/dist/types/compute-engine/engine-scope.d.ts

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 0.51.1 */
 import type { IComputeEngine, Scope, EvalContext } from './global-types';
 export declare function pushScope(ce: IComputeEngine, scope?: Scope, name?: string): void;
 export declare function popScope(ce: IComputeEngine): void;

package/dist/types/compute-engine/engine-sequences.d.ts

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 0.51.1 */
 export declare function declareSequence(ce: IComputeEngine, name: string, def: SequenceDefinition): IComputeEngine;
 export declare function getSequenceStatus(ce: IComputeEngine, name: string): SequenceStatus;
 export declare function getSequence(ce: IComputeEngine, name: string): SequenceInfo | undefined;

package/dist/types/compute-engine/engine-simplification-rules.d.ts

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 0.51.1 */
 /**
  * Internal holder for simplification rules and their cache-staleness marker.
  *

package/dist/types/compute-engine/engine-startup-coordinator.d.ts

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 0.51.1 */
 import type { Expression, IComputeEngine as ComputeEngine, LibraryDefinition } from './global-types';
 export type CommonNumberBindings = {
     Zero: Expression;

package/dist/types/compute-engine/engine-type-resolver.d.ts

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 0.51.1 */
 type ResolverScope = {
     parent: ResolverScope | null;
     types?: Record<string, TypeReference>;

package/dist/types/compute-engine/engine-validation-entrypoints.d.ts

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 0.51.1 */
 import { BoxedType } from '../common/type/boxed-type';
 import type { Expression, Metadata, ExpressionInput } from './global-types';
 type ValidationHost = {

package/dist/types/compute-engine/free-functions.d.ts

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 0.51.1 */
 import type { Type, TypeString } from '../common/type/types';
 import type { LatexString } from './latex-syntax/types';
 import { compile as compileExpr } from './compilation/compile-expression';
@@ -7,6 +7,7 @@ import { compile as compileExpr } from './compilation/compile-expression';
 export declare function _setComputeEngineClass(cls: new () => IComputeEngine): void;
 export declare function getDefaultEngine(): IComputeEngine;
 export declare function parse(latex: LatexString): Expression;
+export declare function box(expr: ExpressionInput): Expression;
 export declare function simplify(expr: LatexString | ExpressionInput): Expression;
 export declare function evaluate(expr: LatexString | ExpressionInput): Expression;
 export declare function N(expr: LatexString | ExpressionInput): Expression;

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

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 0.51.1 */
 import type { BoxedDefinition, Expression, IComputeEngine as ComputeEngine, Scope } from './global-types';
 /***
  * ### THEORY OF OPERATIONS

package/dist/types/compute-engine/global-types.d.ts

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 0.51.1 */
 export type * from './types-serialization';
 export type { ValueDefinition, SequenceDefinition, SequenceStatus, SequenceInfo, OEISSequenceInfo, OEISOptions, OperatorDefinition, BaseDefinition, SimplifyOptions, SymbolDefinition, SymbolDefinitions, LibraryDefinition, AngularUnit, Sign, BaseCollectionHandlers, IndexedCollectionHandlers, CollectionHandlers, TaggedValueDefinition, TaggedOperatorDefinition, BoxedDefinition, BoxedBaseDefinition, BoxedValueDefinition, OperatorDefinitionFlags, BoxedOperatorDefinition, } from './types-definitions';
 export type * from './types-evaluation';

package/dist/types/compute-engine/index.d.ts

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 0.51.1 */
 import { Decimal } from 'decimal.js';
 import { Type, TypeResolver, TypeString } from '../common/type/types';
 import { BoxedType } from '../common/type/boxed-type';
@@ -17,7 +17,7 @@ import { factorPerfectSquare, factorDifferenceOfSquares, factorQuadratic, factor
 import './boxed-expression/serialize';
 import { type ParseEntrypointOptions } from './engine-parse-entrypoint';
 export type * from './global-types';
-export { parse, simplify, evaluate, N, declare, assign, expand, expandAll, factor, solve, compile, getDefaultEngine, } from './free-functions';
+export { parse, box, simplify, evaluate, N, declare, assign, expand, expandAll, factor, solve, compile, getDefaultEngine, } from './free-functions';
 export { validatePattern };
 export { factorPerfectSquare, factorDifferenceOfSquares, factorQuadratic, factorPolynomial, };
 export type { CompileTarget, CompiledOperators, CompiledFunctions, CompilationOptions, CompilationResult, LanguageTarget, TargetSource, CompiledFunction, } from './compilation/types';

package/dist/types/compute-engine/interval/arithmetic.d.ts

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 0.51.1 */
  * Basic interval arithmetic operations
  *
  * @module interval/arithmetic

package/dist/types/compute-engine/interval/comparison.d.ts

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 0.51.1 */
  * Comparison and conditional interval operations
  *
  * @module interval/comparison

package/dist/types/compute-engine/interval/elementary.d.ts

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 0.51.1 */
  * Elementary interval functions (sqrt, pow, exp, ln, abs, floor, ceil, min, max, mod)
  *
  * @module interval/elementary
@@ -127,6 +127,13 @@ export declare function mod(a: Interval | IntervalResult, b: Interval | Interval
  * a half-integer boundary.
  */
 export declare function remainder(a: Interval | IntervalResult, b: Interval | IntervalResult): IntervalResult;
+/**
+ * Heaviside step function on an interval.
+ *
+ * H(x) = 0 for x < 0, 1/2 for x = 0, 1 for x > 0.
+ * Has a jump discontinuity at 0.
+ */
+export declare function heaviside(x: Interval | IntervalResult): IntervalResult;
 /**
  * Sign function.
  *
@@ -142,3 +149,13 @@ export declare function sign(x: Interval | IntervalResult): IntervalResult;
  * negative integers it is monotonic (but alternates direction).
  */
 export declare function gamma(x: Interval | IntervalResult): IntervalResult;
+/**
+ * Natural logarithm of the absolute value of the gamma function.
+ *
+ * gammaln(x) = ln(|gamma(x)|)
+ *
+ * Has the same poles as gamma (at non-positive integers), but approaches
+ * -Infinity near poles instead of ±Infinity. For positive x, gammaln is
+ * monotonically increasing.
+ */
+export declare function gammaln(x: Interval | IntervalResult): IntervalResult;

package/dist/types/compute-engine/interval/index.d.ts

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 0.51.1 */
  * Interval arithmetic library for reliable function evaluation
  *
  * This module provides interval versions of mathematical operations
@@ -10,14 +10,14 @@
  */
 import { ok as _ok, point as _point, containsExtremum as _containsExtremum, unionResults as _unionResults, mergeDomainClip as _mergeDomainClip, isPoint as _isPoint, containsZero as _containsZero, isPositive as _isPositive, isNegative as _isNegative, isNonNegative as _isNonNegative, isNonPositive as _isNonPositive, width as _width, midpoint as _midpoint, getValue as _getValue, unwrap as _unwrap, unwrapOrPropagate as _unwrapOrPropagate } from './util';
 import { add as _add, sub as _sub, mul as _mul, div as _div, negate as _negate } from './arithmetic';
-import { sqrt as _sqrt, square as _square, pow as _pow, powInterval as _powInterval, exp as _exp, ln as _ln, log10 as _log10, log2 as _log2, abs as _abs, floor as _floor, ceil as _ceil, round as _round, fract as _fract, trunc as _trunc, min as _min, max as _max, mod as _mod, remainder as _remainder, sign as _sign } from './elementary';
-import { sin as _sin, cos as _cos, tan as _tan, cot as _cot, sec as _sec, csc as _csc, asin as _asin, acos as _acos, atan as _atan, atan2 as _atan2, sinh as _sinh, cosh as _cosh, tanh as _tanh, asinh as _asinh, acosh as _acosh, atanh as _atanh, acot as _acot, acsc as _acsc, asec as _asec, coth as _coth, csch as _csch, sech as _sech, acoth as _acoth, acsch as _acsch, asech as _asech } from './trigonometric';
+import { sqrt as _sqrt, square as _square, pow as _pow, powInterval as _powInterval, exp as _exp, ln as _ln, log10 as _log10, log2 as _log2, abs as _abs, floor as _floor, ceil as _ceil, round as _round, fract as _fract, trunc as _trunc, min as _min, max as _max, mod as _mod, remainder as _remainder, heaviside as _heaviside, sign as _sign, gamma as _gamma, gammaln as _gammaln } from './elementary';
+import { sin as _sin, cos as _cos, tan as _tan, cot as _cot, sec as _sec, csc as _csc, asin as _asin, acos as _acos, atan as _atan, atan2 as _atan2, sinh as _sinh, cosh as _cosh, tanh as _tanh, asinh as _asinh, acosh as _acosh, atanh as _atanh, acot as _acot, acsc as _acsc, asec as _asec, coth as _coth, csch as _csch, sech as _sech, acoth as _acoth, acsch as _acsch, asech as _asech, sinc as _sinc, fresnelS as _fresnelS, fresnelC as _fresnelC } from './trigonometric';
 import { less as _less, lessEqual as _lessEqual, greater as _greater, greaterEqual as _greaterEqual, equal as _equal, notEqual as _notEqual, and as _and, or as _or, not as _not, piecewise as _piecewise, clamp as _clamp } from './comparison';
 export type { Interval, IntervalResult, BoolInterval } from './types';
 export { ok, point, containsExtremum, unionResults, mergeDomainClip, isPoint, containsZero, isPositive, isNegative, isNonNegative, isNonPositive, width, midpoint, getValue, unwrap, unwrapOrPropagate, } from './util';
 export { add, sub, mul, div, negate, _mul } from './arithmetic';
-export { sqrt, square, pow, powInterval, exp, ln, log10, log2, abs, floor, ceil, round, fract, trunc, min, max, mod, remainder, sign, } from './elementary';
-export { sin, cos, tan, cot, sec, csc, asin, acos, atan, atan2, sinh, cosh, tanh, asinh, acosh, atanh, acot, acsc, asec, coth, csch, sech, acoth, acsch, asech, } from './trigonometric';
+export { sqrt, square, pow, powInterval, exp, ln, log10, log2, abs, floor, ceil, round, fract, trunc, min, max, mod, remainder, heaviside, sign, gamma, gammaln, } from './elementary';
+export { sin, cos, tan, cot, sec, csc, asin, acos, atan, atan2, sinh, cosh, tanh, asinh, acosh, atanh, acot, acsc, asec, coth, csch, sech, acoth, acsch, asech, sinc, fresnelS, fresnelC, } from './trigonometric';
 export { less, lessEqual, greater, greaterEqual, equal, notEqual, and, or, not, piecewise, clamp, } from './comparison';
 /**
  * The complete interval arithmetic library object.
@@ -65,7 +65,10 @@ export declare const IntervalArithmetic: {
     max: typeof _max;
     mod: typeof _mod;
     remainder: typeof _remainder;
+    heaviside: typeof _heaviside;
     sign: typeof _sign;
+    gamma: typeof _gamma;
+    gammaln: typeof _gammaln;
     sin: typeof _sin;
     cos: typeof _cos;
     tan: typeof _tan;
@@ -91,6 +94,9 @@ export declare const IntervalArithmetic: {
     acoth: typeof _acoth;
     acsch: typeof _acsch;
     asech: typeof _asech;
+    sinc: typeof _sinc;
+    fresnelS: typeof _fresnelS;
+    fresnelC: typeof _fresnelC;
     less: typeof _less;
     lessEqual: typeof _lessEqual;
     greater: typeof _greater;