@cortex-js/compute-engine 0.34.0 → 0.35.0

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

@@ -0,0 +1,93 @@
+/* 0.35.0 */
+ * JavaScript interval arithmetic compilation target
+ *
+ * Compiles mathematical expressions to JavaScript code using interval arithmetic
+ * for reliable function evaluation with singularity detection.
+ *
+ * @module compilation/interval-javascript-target
+ */
+import type { BoxedExpression } from '../global-types';
+import type { CompileTarget, CompiledOperators, CompiledFunctions, LanguageTarget, CompilationOptions, CompiledExecutable } from './types';
+/**
+ * JavaScript function that wraps compiled interval arithmetic code.
+ *
+ * Injects the _IA library and provides input conversion from various formats.
+ */
+export declare class ComputeEngineIntervalFunction extends Function {
+    IA: {
+        ok: typeof import("../interval").ok;
+        point: typeof import("../interval").point;
+        containsExtremum: typeof import("../interval").containsExtremum;
+        unionResults: typeof import("../interval").unionResults;
+        mergeDomainClip: typeof import("../interval").mergeDomainClip;
+        isPoint: typeof import("../interval").isPoint;
+        containsZero: typeof import("../interval").containsZero;
+        isPositive: typeof import("../interval").isPositive;
+        isNegative: typeof import("../interval").isNegative;
+        isNonNegative: typeof import("../interval").isNonNegative;
+        isNonPositive: typeof import("../interval").isNonPositive;
+        width: typeof import("../interval").width;
+        midpoint: typeof import("../interval").midpoint;
+        getValue: typeof import("../interval").getValue;
+        unwrap: typeof import("../interval").unwrap;
+        unwrapOrPropagate: typeof import("../interval").unwrapOrPropagate;
+        add: typeof import("../interval").add;
+        sub: typeof import("../interval").sub;
+        mul: typeof import("../interval").mul;
+        div: typeof import("../interval").div;
+        negate: typeof import("../interval").negate;
+        sqrt: typeof import("../interval").sqrt;
+        square: typeof import("../interval").square;
+        pow: typeof import("../interval").pow;
+        powInterval: typeof import("../interval").powInterval;
+        exp: typeof import("../interval").exp;
+        ln: typeof import("../interval").ln;
+        log10: typeof import("../interval").log10;
+        log2: typeof import("../interval").log2;
+        abs: typeof import("../interval").abs;
+        floor: typeof import("../interval").floor;
+        ceil: typeof import("../interval").ceil;
+        round: typeof import("../interval").round;
+        min: typeof import("../interval").min;
+        max: typeof import("../interval").max;
+        mod: typeof import("../interval").mod;
+        sign: typeof import("../interval").sign;
+        sin: typeof import("../interval").sin;
+        cos: typeof import("../interval").cos;
+        tan: typeof import("../interval").tan;
+        cot: typeof import("../interval").cot;
+        sec: typeof import("../interval").sec;
+        csc: typeof import("../interval").csc;
+        asin: typeof import("../interval").asin;
+        acos: typeof import("../interval").acos;
+        atan: typeof import("../interval").atan;
+        atan2: typeof import("../interval").atan2;
+        sinh: typeof import("../interval").sinh;
+        cosh: typeof import("../interval").cosh;
+        tanh: typeof import("../interval").tanh;
+        asinh: typeof import("../interval").asinh;
+        acosh: typeof import("../interval").acosh;
+        atanh: typeof import("../interval").atanh;
+        less: typeof import("../interval").less;
+        lessEqual: typeof import("../interval").lessEqual;
+        greater: typeof import("../interval").greater;
+        greaterEqual: typeof import("../interval").greaterEqual;
+        equal: typeof import("../interval").equal;
+        notEqual: typeof import("../interval").notEqual;
+        and: typeof import("../interval").and;
+        or: typeof import("../interval").or;
+        not: typeof import("../interval").not;
+        piecewise: typeof import("../interval").piecewise;
+        clamp: typeof import("../interval").clamp;
+    };
+    constructor(body: string, preamble?: string);
+}
+/**
+ * Interval arithmetic JavaScript target implementation.
+ */
+export declare class IntervalJavaScriptTarget implements LanguageTarget {
+    getOperators(): CompiledOperators;
+    getFunctions(): CompiledFunctions;
+    createTarget(options?: Partial<CompileTarget>): CompileTarget;
+    compileToExecutable(expr: BoxedExpression, options?: CompilationOptions): CompiledExecutable;
+}

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

@@ -1,4 +1,4 @@
-/* 0.34.0 */
+/* 0.35.0 */
 import { chop, factorial, gcd, lcm, limit } from '../numerics/numeric';
 import { gamma, gammaln } from '../numerics/special-functions';
 import { interquartileRange, kurtosis, mean, median, mode, populationStandardDeviation, populationVariance, quartiles, skewness, standardDeviation, variance } from '../numerics/statistics';

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

@@ -1,4 +1,4 @@
-/* 0.34.0 */
+/* 0.35.0 */
 import type { BoxedExpression } from '../global-types';
 /**
  * Source code in the target language

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

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

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

@@ -1,4 +1,4 @@
-/* 0.34.0 */
+/* 0.35.0 */
 import type { BoxedDefinition, BoxedExpression, ComputeEngine, Scope } from './global-types';
 /***
  * ### THEORY OF OPERATIONS

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

@@ -1,4 +1,4 @@
-/* 0.34.0 */
+/* 0.35.0 */
 import type { OneOf } from '../common/one-of';
 import type { Expression, MathJsonNumberObject, MathJsonStringObject, MathJsonFunctionObject, MathJsonSymbolObject, MathJsonSymbol, MathJsonDictionaryObject } from '../math-json';
 import type { Type, TypeReference, TypeResolver, TypeString } from '../common/type/types';
@@ -1899,7 +1899,7 @@ export interface SequenceDefinition {
     variable?: string;
     /**
      * Index variable names for multi-index sequences.
-     * Example: `['n', 'k']` for Pascal's triangle P_{n,k}
+     * Example: `['n', 'k']` for Pascal's triangle `P\_{n,k}`
      *
      * If provided, this takes precedence over `variable`.
      */

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

@@ -1,4 +1,4 @@
-/* 0.34.0 */
+/* 0.35.0 */
 import { Decimal } from 'decimal.js';
 import { Type, TypeResolver, TypeString } from '../common/type/types';
 import { BoxedType } from '../common/type/boxed-type';
@@ -19,6 +19,8 @@ export { factor, factorPerfectSquare, factorDifferenceOfSquares, factorQuadratic
 export type { CompileTarget, CompiledOperators, CompiledFunctions, CompilationOptions, CompiledExecutable, LanguageTarget, TargetSource, CompiledFunction, } from './compilation/types';
 export { JavaScriptTarget } from './compilation/javascript-target';
 export { GLSLTarget } from './compilation/glsl-target';
+export { IntervalJavaScriptTarget } from './compilation/interval-javascript-target';
+export { IntervalGLSLTarget } from './compilation/interval-glsl-target';
 export { BaseCompiler } from './compilation/base-compiler';
 import type { LanguageTarget } from './compilation/types';
 /**

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

@@ -0,0 +1,56 @@
+/* 0.35.0 */
+ * Basic interval arithmetic operations
+ *
+ * @module interval/arithmetic
+ */
+import type { Interval, IntervalResult } from './types';
+/**
+ * Add two intervals (or IntervalResults).
+ *
+ * [a, b] + [c, d] = [a + c, b + d]
+ *
+ * Addition is always defined and produces a valid interval.
+ * If inputs are IntervalResults, propagates errors (empty, entire, singular).
+ */
+export declare function add(a: Interval | IntervalResult, b: Interval | IntervalResult): IntervalResult;
+/**
+ * Subtract two intervals (or IntervalResults).
+ *
+ * [a, b] - [c, d] = [a - d, b - c]
+ *
+ * Subtraction is always defined and produces a valid interval.
+ * If inputs are IntervalResults, propagates errors (empty, entire, singular).
+ */
+export declare function sub(a: Interval | IntervalResult, b: Interval | IntervalResult): IntervalResult;
+/**
+ * Negate an interval (or IntervalResult).
+ *
+ * -[a, b] = [-b, -a]
+ */
+export declare function negate(x: Interval | IntervalResult): IntervalResult;
+/**
+ * Internal multiplication helper that returns plain Interval.
+ *
+ * Used by div() and other operations that need plain interval results.
+ */
+export declare function _mul(a: Interval, b: Interval): Interval;
+/**
+ * Multiply two intervals (or IntervalResults).
+ *
+ * All four endpoint products are computed and the result
+ * spans from minimum to maximum.
+ * If inputs are IntervalResults, propagates errors (empty, entire, singular).
+ */
+export declare function mul(a: Interval | IntervalResult, b: Interval | IntervalResult): IntervalResult;
+/**
+ * Divide two intervals (or IntervalResults).
+ *
+ * Division by an interval containing zero produces special results:
+ * - If divisor strictly contains 0 (not just touching): singular
+ * - If divisor is exactly [0, 0]: empty
+ * - If divisor touches 0 at one bound: partial result
+ *
+ * This is the key operation for singularity detection in plotting.
+ * If inputs are IntervalResults, propagates errors (empty, entire, singular).
+ */
+export declare function div(a: Interval | IntervalResult, b: Interval | IntervalResult): IntervalResult;

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

@@ -0,0 +1,70 @@
+/* 0.35.0 */
+ * Comparison and conditional interval operations
+ *
+ * @module interval/comparison
+ */
+import type { Interval, IntervalResult, BoolInterval } from './types';
+/**
+ * Less than comparison for intervals.
+ *
+ * Returns:
+ * - 'true' if a is entirely less than b (a.hi < b.lo)
+ * - 'false' if a is entirely greater than or equal to b (a.lo >= b.hi)
+ * - 'maybe' if intervals overlap
+ */
+export declare function less(a: Interval, b: Interval): BoolInterval;
+/**
+ * Less than or equal comparison for intervals.
+ */
+export declare function lessEqual(a: Interval, b: Interval): BoolInterval;
+/**
+ * Greater than comparison for intervals.
+ */
+export declare function greater(a: Interval, b: Interval): BoolInterval;
+/**
+ * Greater than or equal comparison for intervals.
+ */
+export declare function greaterEqual(a: Interval, b: Interval): BoolInterval;
+/**
+ * Equality comparison for intervals.
+ *
+ * Returns:
+ * - 'true' only if both are point intervals with same value
+ * - 'false' if intervals don't overlap
+ * - 'maybe' if intervals overlap
+ */
+export declare function equal(a: Interval, b: Interval): BoolInterval;
+/**
+ * Not equal comparison for intervals.
+ */
+export declare function notEqual(a: Interval, b: Interval): BoolInterval;
+/**
+ * Logical AND for boolean intervals.
+ */
+export declare function and(a: BoolInterval, b: BoolInterval): BoolInterval;
+/**
+ * Logical OR for boolean intervals.
+ */
+export declare function or(a: BoolInterval, b: BoolInterval): BoolInterval;
+/**
+ * Logical NOT for boolean intervals.
+ */
+export declare function not(a: BoolInterval): BoolInterval;
+/**
+ * Piecewise (conditional) evaluation for intervals.
+ *
+ * When the condition is indeterminate ('maybe'), both branches
+ * are evaluated and the union (hull) is returned.
+ *
+ * @param x - Input interval
+ * @param condition - Function that evaluates the condition
+ * @param trueBranch - Function for when condition is true
+ * @param falseBranch - Function for when condition is false
+ */
+export declare function piecewise(x: Interval, condition: (x: Interval) => BoolInterval, trueBranch: (x: Interval) => IntervalResult, falseBranch: (x: Interval) => IntervalResult): IntervalResult;
+/**
+ * Clamp an interval to a range.
+ *
+ * clamp(x, lo, hi) returns x clamped to [lo, hi].
+ */
+export declare function clamp(x: Interval, lo: Interval, hi: Interval): IntervalResult;

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

@@ -0,0 +1,100 @@
+/* 0.35.0 */
+ * Elementary interval functions (sqrt, pow, exp, ln, abs, floor, ceil, min, max, mod)
+ *
+ * @module interval/elementary
+ */
+import type { Interval, IntervalResult } from './types';
+/**
+ * Square root of an interval (or IntervalResult).
+ *
+ * - Entirely negative: empty (no real values)
+ * - Entirely non-negative: straightforward monotonic
+ * - Straddles zero: partial result with lower bound clipped
+ */
+export declare function sqrt(x: Interval | IntervalResult): IntervalResult;
+/**
+ * Square an interval (or IntervalResult).
+ *
+ * Need to handle sign change at 0 since x^2 is not monotonic.
+ */
+export declare function square(x: Interval | IntervalResult): IntervalResult;
+/**
+ * Power function for intervals.
+ *
+ * Handles integer and fractional exponents differently:
+ * - Integer exponents: consider sign and parity
+ * - Negative integer: x^(-n) = 1/x^n, singular if base contains 0
+ * - Fractional: requires non-negative base for real result
+ */
+export declare function pow(base: Interval, exp: number): IntervalResult;
+/**
+ * Interval power where the exponent is also an interval.
+ *
+ * For simplicity, we evaluate at the four corners and take the hull.
+ * This requires base to be positive for real results.
+ */
+export declare function powInterval(base: Interval, exp: Interval): IntervalResult;
+/**
+ * Exponential function (e^x).
+ *
+ * Always valid, monotonically increasing.
+ */
+export declare function exp(x: Interval | IntervalResult): IntervalResult;
+/**
+ * Natural logarithm.
+ *
+ * Domain: positive reals (x > 0)
+ * - Entirely non-positive: empty
+ * - Entirely positive: straightforward monotonic
+ * - Contains/touches zero: partial with -Infinity lower bound
+ */
+export declare function ln(x: Interval): IntervalResult;
+/**
+ * Base-10 logarithm.
+ */
+export declare function log10(x: Interval): IntervalResult;
+/**
+ * Base-2 logarithm.
+ */
+export declare function log2(x: Interval): IntervalResult;
+/**
+ * Absolute value of an interval.
+ */
+export declare function abs(x: Interval): IntervalResult;
+/**
+ * Floor function (greatest integer <= x).
+ *
+ * Note: Produces step-function discontinuities when floor(x.lo) != floor(x.hi).
+ */
+export declare function floor(x: Interval): IntervalResult;
+/**
+ * Ceiling function (least integer >= x).
+ *
+ * Note: Produces step-function discontinuities when ceil(x.lo) != ceil(x.hi).
+ */
+export declare function ceil(x: Interval): IntervalResult;
+/**
+ * Round to nearest integer.
+ */
+export declare function round(x: Interval): IntervalResult;
+/**
+ * Minimum of two intervals.
+ */
+export declare function min(a: Interval, b: Interval): IntervalResult;
+/**
+ * Maximum of two intervals.
+ */
+export declare function max(a: Interval, b: Interval): IntervalResult;
+/**
+ * Modulo (remainder) operation.
+ *
+ * Has discontinuities and is complex with interval divisor.
+ * Conservative approach: if interval spans a period, return [0, |b|).
+ */
+export declare function mod(a: Interval, b: Interval): IntervalResult;
+/**
+ * Sign function.
+ *
+ * Returns -1, 0, or 1 depending on the sign.
+ */
+export declare function sign(x: Interval): IntervalResult;

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

@@ -0,0 +1,93 @@
+/* 0.35.0 */
+ * Interval arithmetic library for reliable function evaluation
+ *
+ * This module provides interval versions of mathematical operations
+ * that return guaranteed enclosures of the true result. It's designed
+ * for use in plotting applications to detect singularities and enable
+ * adaptive sampling.
+ *
+ * @module interval
+ */
+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, min as _min, max as _max, mod as _mod, 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 } 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, min, max, mod, sign, } from './elementary';
+export { sin, cos, tan, cot, sec, csc, asin, acos, atan, atan2, sinh, cosh, tanh, asinh, acosh, atanh, } from './trigonometric';
+export { less, lessEqual, greater, greaterEqual, equal, notEqual, and, or, not, piecewise, clamp, } from './comparison';
+/**
+ * The complete interval arithmetic library object.
+ *
+ * This is the runtime library injected as `_IA` in compiled
+ * interval arithmetic functions.
+ */
+export declare const IntervalArithmetic: {
+    ok: typeof _ok;
+    point: typeof _point;
+    containsExtremum: typeof _containsExtremum;
+    unionResults: typeof _unionResults;
+    mergeDomainClip: typeof _mergeDomainClip;
+    isPoint: typeof _isPoint;
+    containsZero: typeof _containsZero;
+    isPositive: typeof _isPositive;
+    isNegative: typeof _isNegative;
+    isNonNegative: typeof _isNonNegative;
+    isNonPositive: typeof _isNonPositive;
+    width: typeof _width;
+    midpoint: typeof _midpoint;
+    getValue: typeof _getValue;
+    unwrap: typeof _unwrap;
+    unwrapOrPropagate: typeof _unwrapOrPropagate;
+    add: typeof _add;
+    sub: typeof _sub;
+    mul: typeof _mul;
+    div: typeof _div;
+    negate: typeof _negate;
+    sqrt: typeof _sqrt;
+    square: typeof _square;
+    pow: typeof _pow;
+    powInterval: typeof _powInterval;
+    exp: typeof _exp;
+    ln: typeof _ln;
+    log10: typeof _log10;
+    log2: typeof _log2;
+    abs: typeof _abs;
+    floor: typeof _floor;
+    ceil: typeof _ceil;
+    round: typeof _round;
+    min: typeof _min;
+    max: typeof _max;
+    mod: typeof _mod;
+    sign: typeof _sign;
+    sin: typeof _sin;
+    cos: typeof _cos;
+    tan: typeof _tan;
+    cot: typeof _cot;
+    sec: typeof _sec;
+    csc: typeof _csc;
+    asin: typeof _asin;
+    acos: typeof _acos;
+    atan: typeof _atan;
+    atan2: typeof _atan2;
+    sinh: typeof _sinh;
+    cosh: typeof _cosh;
+    tanh: typeof _tanh;
+    asinh: typeof _asinh;
+    acosh: typeof _acosh;
+    atanh: typeof _atanh;
+    less: typeof _less;
+    lessEqual: typeof _lessEqual;
+    greater: typeof _greater;
+    greaterEqual: typeof _greaterEqual;
+    equal: typeof _equal;
+    notEqual: typeof _notEqual;
+    and: typeof _and;
+    or: typeof _or;
+    not: typeof _not;
+    piecewise: typeof _piecewise;
+    clamp: typeof _clamp;
+};

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

@@ -0,0 +1,105 @@
+/* 0.35.0 */
+ * Trigonometric interval functions
+ *
+ * @module interval/trigonometric
+ */
+import type { Interval, IntervalResult } from './types';
+/**
+ * Sine of an interval.
+ *
+ * Sin is bounded [-1, 1] and periodic with extrema at pi/2 + n*pi.
+ */
+export declare function sin(x: Interval): IntervalResult;
+/**
+ * Cosine of an interval.
+ *
+ * Cos is bounded [-1, 1] and periodic with extrema at n*pi.
+ */
+export declare function cos(x: Interval): IntervalResult;
+/**
+ * Tangent of an interval.
+ *
+ * Has singularities at pi/2 + n*pi. Within a single branch,
+ * tan is monotonically increasing.
+ */
+export declare function tan(x: Interval): IntervalResult;
+/**
+ * Cotangent of an interval.
+ *
+ * cot(x) = cos(x)/sin(x), has singularities at n*pi.
+ */
+export declare function cot(x: Interval): IntervalResult;
+/**
+ * Secant of an interval.
+ *
+ * sec(x) = 1/cos(x), has singularities at pi/2 + n*pi.
+ */
+export declare function sec(x: Interval): IntervalResult;
+/**
+ * Cosecant of an interval.
+ *
+ * csc(x) = 1/sin(x), has singularities at n*pi.
+ */
+export declare function csc(x: Interval): IntervalResult;
+/**
+ * Arc sine (inverse sine).
+ *
+ * Domain: [-1, 1], Range: [-pi/2, pi/2]
+ */
+export declare function asin(x: Interval): IntervalResult;
+/**
+ * Arc cosine (inverse cosine).
+ *
+ * Domain: [-1, 1], Range: [0, pi]
+ */
+export declare function acos(x: Interval): IntervalResult;
+/**
+ * Arc tangent (inverse tangent).
+ *
+ * Domain: all reals, Range: (-pi/2, pi/2)
+ * Monotonically increasing.
+ */
+export declare function atan(x: Interval): IntervalResult;
+/**
+ * Two-argument arc tangent.
+ *
+ * atan2(y, x) gives the angle of the point (x, y).
+ * Handles all quadrants correctly.
+ */
+export declare function atan2(y: Interval, x: Interval): IntervalResult;
+/**
+ * Hyperbolic sine.
+ *
+ * Domain: all reals, monotonically increasing.
+ */
+export declare function sinh(x: Interval): IntervalResult;
+/**
+ * Hyperbolic cosine.
+ *
+ * Domain: all reals, minimum at x=0.
+ */
+export declare function cosh(x: Interval): IntervalResult;
+/**
+ * Hyperbolic tangent.
+ *
+ * Domain: all reals, Range: (-1, 1), monotonically increasing.
+ */
+export declare function tanh(x: Interval): IntervalResult;
+/**
+ * Inverse hyperbolic sine.
+ *
+ * Domain: all reals, monotonically increasing.
+ */
+export declare function asinh(x: Interval): IntervalResult;
+/**
+ * Inverse hyperbolic cosine.
+ *
+ * Domain: [1, +Infinity)
+ */
+export declare function acosh(x: Interval): IntervalResult;
+/**
+ * Inverse hyperbolic tangent.
+ *
+ * Domain: (-1, 1)
+ */
+export declare function atanh(x: Interval): IntervalResult;

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

@@ -0,0 +1,50 @@
+/* 0.35.0 */
+ * Interval arithmetic types for reliable function evaluation
+ *
+ * @module interval/types
+ */
+/**
+ * A closed interval [lo, hi] representing a range of real numbers.
+ *
+ * Bounds may be -Infinity or +Infinity for unbounded ranges.
+ * Invariant: lo <= hi (empty intervals are represented differently)
+ */
+export interface Interval {
+    /** Lower bound (toward -Infinity), may be -Infinity */
+    lo: number;
+    /** Upper bound (toward +Infinity), may be +Infinity */
+    hi: number;
+}
+/**
+ * Result of an interval operation.
+ *
+ * Operations return structured results that preserve information for plotting:
+ * - `interval`: Normal computation with valid interval
+ * - `empty`: No valid values (e.g., ln([-2, -1]))
+ * - `entire`: Result spans all reals (-Infinity, +Infinity)
+ * - `singular`: Contains pole/asymptote, needs subdivision
+ * - `partial`: Valid interval with domain clipping info
+ */
+export type IntervalResult = {
+    kind: 'interval';
+    value: Interval;
+} | {
+    kind: 'empty';
+} | {
+    kind: 'entire';
+} | {
+    kind: 'singular';
+    at?: number;
+} | {
+    kind: 'partial';
+    value: Interval;
+    domainClipped: 'lo' | 'hi' | 'both';
+};
+/**
+ * Three-valued logic for interval comparisons.
+ *
+ * - `true`: Definitely true for all values in the intervals
+ * - `false`: Definitely false for all values in the intervals
+ * - `maybe`: Indeterminate - intervals overlap
+ */
+export type BoolInterval = 'true' | 'false' | 'maybe';