@danielsimonjr/mathts-functions 0.2.3 → 0.2.5

package/dist/typed/cas.d.ts

@@ -0,0 +1,691 @@
+/**
+ * Symbolic CAS (Computer Algebra System) Functions
+ *
+ * Provides 28 symbolic/semi-symbolic math functions for calculus, transforms,
+ * series expansions, equation solving, and advanced algebra. Functions work
+ * with expression strings and use numerical evaluation via the expression
+ * evaluator when symbolic approaches are not feasible.
+ *
+ * Categories:
+ * - Calculus (8): integrate, limit, partialDerivative, directionalDerivative,
+ *   gradientSymbolic, jacobian, laplacian, divergence
+ * - Transforms (4): laplace, inverseLaplace, fourierSeries, zTransform
+ * - Series (4): taylor, multivariateTaylor, series, seriesCoefficient
+ * - Solver (4): solve, implicitDiff, summation, symbolicProduct
+ * - Advanced (8): assume, asymptotic, groebnerBasis, minimalPolynomial,
+ *   toRadicals, piecewise, odeGeneral, curl
+ * - Batch CAS (4): simplify, derivative, expand, factor — with worker fan-out
+ *   for arrays of length ≥ 16 (Slice 5.14).
+ *
+ * @packageDocumentation
+ */
+import { parse } from '../factories/evaluate.js';
+type f64 = number;
+type MathNode = ReturnType<typeof parse>;
+/**
+ * Symbolic/numerical integration.
+ *
+ * For basic symbolic forms (polynomials, trig, exp), returns the symbolic
+ * antiderivative. For definite integrals (a, b provided), falls back to
+ * numerical integration using Simpson's rule.
+ *
+ * @param expr - Expression string to integrate
+ * @param varName - Variable of integration
+ * @param a - Optional lower bound (definite integral)
+ * @param b - Optional upper bound (definite integral)
+ * @returns Symbolic antiderivative string or numerical result
+ *
+ * @example
+ * integrate('x^2', 'x')          // => 'x^3/3'
+ * integrate('sin(x)', 'x')       // => '-cos(x)'
+ * integrate('x^2', 'x', 0, 1)   // => 0.3333...
+ */
+export declare function integrate(expr: string, varName: string, a?: f64, b?: f64): string | f64;
+/**
+ * Compute symbolic limits using numerical approach and L'Hopital's rule.
+ *
+ * Handles standard limits, 0/0 indeterminate forms via L'Hopital,
+ * and one-sided limits.
+ *
+ * @param expr - Expression string
+ * @param varName - Variable approaching the limit
+ * @param value - Value being approached (can be Infinity or -Infinity)
+ * @param dir - Direction: 'left', 'right', or undefined for both
+ * @returns The limit value
+ *
+ * @example
+ * limit('sin(x)/x', 'x', 0)        // => 1
+ * limit('1/x', 'x', 0, 'right')    // => Infinity
+ * limit('(x^2-1)/(x-1)', 'x', 1)   // => 2
+ */
+export declare function limit(expr: string, varName: string, value: f64, dir?: 'left' | 'right'): f64;
+/**
+ * Compute the partial derivative of an expression with respect to a variable.
+ *
+ * Uses numerical differentiation (4th-order central difference).
+ * Returns the derivative as a function that can be evaluated at a point.
+ *
+ * @param expr - Expression string
+ * @param varName - Variable to differentiate with respect to
+ * @param scope - Variable values at which to evaluate
+ * @returns Numerical value of the partial derivative
+ *
+ * @example
+ * partialDerivative('x^2 + y^2', 'x', { x: 3, y: 4 }) // => 6
+ * partialDerivative('sin(x*y)', 'x', { x: 0, y: 1 })   // => 1
+ */
+export declare function partialDerivative(expr: string, varName: string, scope: Record<string, f64>): f64;
+/**
+ * Compute the directional derivative of an expression.
+ *
+ * The directional derivative is the dot product of the gradient with
+ * the (normalized) direction vector.
+ *
+ * @param expr - Expression string
+ * @param vars - Variable names
+ * @param direction - Direction vector (will be normalized)
+ * @param scope - Variable values at which to evaluate
+ * @returns Directional derivative value
+ *
+ * @example
+ * directionalDerivative('x^2 + y^2', ['x', 'y'], [1, 0], { x: 3, y: 4 }) // => 6
+ */
+export declare function directionalDerivative(expr: string, vars: string[], direction: f64[], scope: Record<string, f64>): f64;
+/**
+ * Compute the symbolic gradient vector of an expression.
+ *
+ * Returns an array of partial derivative values at the given point.
+ *
+ * @param expr - Expression string
+ * @param vars - Variable names
+ * @param scope - Variable values at which to evaluate
+ * @returns Array of partial derivative values
+ *
+ * @example
+ * gradientSymbolic('x^2 + y^2', ['x', 'y'], { x: 3, y: 4 }) // => [6, 8]
+ */
+export declare function gradientSymbolic(expr: string, vars: string[], scope: Record<string, f64>): f64[];
+/**
+ * Compute the Jacobian matrix of a vector-valued function.
+ *
+ * J[i][j] = partial derivative of exprs[i] with respect to vars[j].
+ *
+ * @param exprs - Array of expression strings (vector field components)
+ * @param vars - Variable names
+ * @param scope - Variable values at which to evaluate
+ * @returns 2D array (matrix) of partial derivatives
+ *
+ * @example
+ * jacobian(['x*y', 'x^2'], ['x', 'y'], { x: 2, y: 3 })
+ * // => [[3, 2], [4, 0]]
+ */
+export declare function jacobian(exprs: string[], vars: string[], scope: Record<string, f64>): f64[][];
+/**
+ * Compute the Laplacian of a scalar field.
+ *
+ * The Laplacian is the sum of all second partial derivatives:
+ * nabla^2 f = sum_i d^2f/dx_i^2
+ *
+ * @param expr - Expression string
+ * @param vars - Variable names
+ * @param scope - Variable values at which to evaluate
+ * @returns Laplacian value
+ *
+ * @example
+ * laplacian('x^2 + y^2 + z^2', ['x', 'y', 'z'], { x: 1, y: 2, z: 3 }) // => 6
+ */
+export declare function laplacian(expr: string, vars: string[], scope: Record<string, f64>): f64;
+/**
+ * Compute the divergence of a vector field.
+ *
+ * div(F) = df1/dx1 + df2/dx2 + ... + dfn/dxn
+ *
+ * @param exprs - Array of expression strings (vector field components)
+ * @param vars - Variable names (must match length of exprs)
+ * @param scope - Variable values at which to evaluate
+ * @returns Divergence value
+ *
+ * @example
+ * divergence(['x^2', 'y^2', 'z^2'], ['x', 'y', 'z'], { x: 1, y: 2, z: 3 })
+ * // => 2 + 4 + 6 = 12
+ */
+export declare function divergence(exprs: string[], vars: string[], scope: Record<string, f64>): f64;
+/**
+ * Compute the Laplace transform of an expression.
+ *
+ * Uses a table-based approach for common functions: constants, polynomials,
+ * exponentials, sin, cos.
+ *
+ * @param expr - Time-domain expression string
+ * @param t - Time variable name
+ * @param s - Frequency variable name
+ * @returns Laplace transform as an expression string
+ *
+ * @example
+ * laplace('1', 't', 's')           // => '1/s'
+ * laplace('t^2', 't', 's')         // => '2/s^3'
+ * laplace('sin(t)', 't', 's')      // => '1/(s^2 + 1)'
+ * laplace('exp(-t)', 't', 's')     // => '1/(s + 1)'
+ */
+export declare function laplace(expr: string, t: string, s: string): string;
+/**
+ * Compute the inverse Laplace transform of an expression.
+ *
+ * Uses table lookup and partial fraction patterns.
+ *
+ * @param expr - Frequency-domain expression string
+ * @param s - Frequency variable name
+ * @param t - Time variable name
+ * @returns Inverse Laplace transform as an expression string
+ *
+ * @example
+ * inverseLaplace('1/s', 's', 't')         // => '1'
+ * inverseLaplace('1/(s + 1)', 's', 't')   // => 'exp(-1*t)'
+ */
+export declare function inverseLaplace(expr: string, s: string, t: string): string;
+/**
+ * Compute Fourier series coefficients of a periodic function.
+ *
+ * Computes a0, an, bn coefficients for the Fourier series representation:
+ * f(x) ~ a0/2 + sum_{k=1}^{n} [a_k cos(k*x) + b_k sin(k*x)]
+ *
+ * Assumes period 2*pi. Coefficients computed numerically.
+ *
+ * @param expr - Expression string (function of varName)
+ * @param varName - Variable name
+ * @param n - Number of harmonics
+ * @returns Object with a0, an[], bn[] coefficients
+ *
+ * @example
+ * fourierSeries('x', 'x', 3)
+ * // => { a0: 0, an: [0, 0, 0], bn: [-2, 1, -0.667] } (approx)
+ */
+export declare function fourierSeries(expr: string, varName: string, n: number): {
+    a0: f64;
+    an: f64[];
+    bn: f64[];
+};
+/**
+ * Compute the Z-transform of a sequence expression.
+ *
+ * Uses table-based lookup for common sequences.
+ *
+ * @param expr - Expression in terms of n (sequence element)
+ * @param n - Sequence index variable
+ * @param z - Z-domain variable
+ * @returns Z-transform as an expression string
+ *
+ * @example
+ * zTransform('1', 'n', 'z')       // => 'z/(z - 1)'
+ * zTransform('n', 'n', 'z')       // => 'z/(z - 1)^2'
+ */
+export declare function zTransform(expr: string, n: string, z: string): string;
+/**
+ * Compute the Taylor series expansion of an expression around a point.
+ *
+ * Computes coefficients numerically using finite differences and returns
+ * the polynomial approximation as a string.
+ *
+ * @param expr - Expression string
+ * @param varName - Variable name
+ * @param x0 - Center of expansion (default 0, i.e., Maclaurin series)
+ * @param n - Order of expansion (default 5)
+ * @returns Taylor polynomial as an expression string
+ *
+ * @example
+ * taylor('sin(x)', 'x', 0, 5)  // => 'x - 0.1666666667*x^3 + 0.008333333333*x^5'
+ * taylor('exp(x)', 'x', 0, 4)  // => '1 + x + 0.5*x^2 + ...'
+ */
+export declare function taylor(expr: string, varName: string, x0?: f64, n?: number): string;
+/**
+ * Compute a multivariate Taylor expansion.
+ *
+ * Returns first-order (linear) approximation for multiple variables:
+ * f(x0) + sum_i df/dx_i * (x_i - x0_i) + ...
+ *
+ * @param expr - Expression string
+ * @param vars - Variable names
+ * @param x0 - Center point values
+ * @param n - Order (currently supports order 1)
+ * @returns Taylor approximation as expression string
+ *
+ * @example
+ * multivariateTaylor('x*y', ['x', 'y'], [1, 1], 1) // => '1 + (x - 1)*y0 + (y - 1)*x0'
+ */
+export declare function multivariateTaylor(expr: string, vars: string[], x0: f64[], n?: number): string;
+/**
+ * Power series expansion (alias for taylor).
+ *
+ * @param expr - Expression string
+ * @param varName - Variable name
+ * @param x0 - Center of expansion (default 0)
+ * @param n - Order (default 5)
+ * @returns Power series as expression string
+ */
+export declare function series(expr: string, varName: string, x0?: f64, n?: number): string;
+/**
+ * Extract the kth coefficient of the Taylor series expansion.
+ *
+ * Returns c_k where f(x) = sum c_k * (x - x0)^k.
+ *
+ * @param expr - Expression string
+ * @param varName - Variable name
+ * @param x0 - Center of expansion
+ * @param k - Index of coefficient to extract
+ * @returns The kth Taylor coefficient
+ *
+ * @example
+ * seriesCoefficient('exp(x)', 'x', 0, 3) // => 1/6 = 0.1667
+ * seriesCoefficient('sin(x)', 'x', 0, 1) // => 1
+ */
+export declare function seriesCoefficient(expr: string, varName: string, x0: f64, k: number): f64;
+/**
+ * Solve an equation for a variable.
+ *
+ * Supports linear, quadratic, and cubic equations. For the expression f(x),
+ * finds roots where f(x) = 0.
+ *
+ * @param expr - Expression string (set equal to 0)
+ * @param varName - Variable to solve for
+ * @returns Array of solutions (real roots)
+ *
+ * @example
+ * solve('x^2 - 4', 'x')      // => [-2, 2]
+ * solve('x^2 + 2*x + 1', 'x') // => [-1]
+ * solve('2*x - 6', 'x')       // => [3]
+ */
+export declare function solve(expr: string, varName: string): f64[];
+/**
+ * Compute dy/dx from an implicit equation F(x, y) = 0.
+ *
+ * Uses the implicit function theorem: dy/dx = -(dF/dx) / (dF/dy)
+ *
+ * @param expr - Expression F(x, y)
+ * @param x - x-variable name
+ * @param y - y-variable name
+ * @param scope - Point at which to evaluate
+ * @returns dy/dx at the given point
+ *
+ * @example
+ * // Circle: x^2 + y^2 - 25 = 0 at (3, 4)
+ * implicitDiff('x^2 + y^2 - 25', 'x', 'y', { x: 3, y: 4 }) // => -0.75
+ */
+export declare function implicitDiff(expr: string, x: string, y: string, scope: Record<string, f64>): f64;
+/**
+ * Compute a symbolic summation.
+ *
+ * For known closed forms (constant, linear, quadratic, cubic), returns
+ * the exact result. Otherwise falls back to numerical summation.
+ *
+ * @param expr - Expression to sum (function of varName)
+ * @param varName - Summation index variable
+ * @param a - Lower bound (integer)
+ * @param b - Upper bound (integer)
+ * @returns Sum value
+ *
+ * @example
+ * summation('k', 'k', 1, 100)     // => 5050
+ * summation('k^2', 'k', 1, 10)    // => 385
+ * summation('1', 'k', 1, 50)      // => 50
+ */
+export declare function summation(expr: string, varName: string, a: number, b: number): f64;
+/**
+ * Compute a symbolic product.
+ *
+ * Computes the product of expr for varName from a to b.
+ *
+ * @param expr - Expression to multiply (function of varName)
+ * @param varName - Product index variable
+ * @param a - Lower bound (integer)
+ * @param b - Upper bound (integer)
+ * @returns Product value
+ *
+ * @example
+ * symbolicProduct('k', 'k', 1, 5)    // => 120 (= 5!)
+ * symbolicProduct('2*k', 'k', 1, 4)  // => 384
+ */
+export declare function symbolicProduct(expr: string, varName: string, a: number, b: number): f64;
+/**
+ * Declare an assumption about a variable's properties.
+ *
+ * Stores assumptions that can be queried by other CAS functions
+ * (e.g., simplification, integration).
+ *
+ * @param varName - Variable name
+ * @param property - Property to assume ('real', 'positive', 'negative', 'integer', 'nonzero')
+ *
+ * @example
+ * assume('x', 'positive')
+ * assume('n', 'integer')
+ */
+export declare function assume(varName: string, property: string): void;
+/**
+ * Query assumptions about a variable.
+ *
+ * @param varName - Variable name
+ * @returns Set of assumed properties, or empty set if none
+ */
+export declare function getAssumptions(varName: string): Set<string>;
+/**
+ * Clear all assumptions about a variable (or all variables).
+ *
+ * @param varName - Variable name, or undefined to clear all
+ */
+export declare function clearAssumptions(varName?: string): void;
+/**
+ * Compute the asymptotic expansion of an expression.
+ *
+ * Finds the leading-order behavior as the variable approaches
+ * the specified limit (typically infinity).
+ *
+ * @param expr - Expression string
+ * @param varName - Variable name
+ * @param towards - Limit point (default: Infinity)
+ * @returns Object with leadingTerm and order
+ *
+ * @example
+ * asymptotic('(x^2 + 1) / x', 'x', Infinity)
+ * // => { leadingTerm: 'x', order: 1 }
+ */
+export declare function asymptotic(expr: string, varName: string, towards?: f64): {
+    leadingTerm: string;
+    order: f64;
+    coefficient: f64;
+};
+/**
+ * Compute a Groebner basis for a system of polynomial equations.
+ *
+ * Implements Buchberger's algorithm for small systems (up to 3 variables,
+ * low degree). Polynomials are represented as expression strings set to 0.
+ *
+ * This is a simplified implementation that works with monomials represented
+ * internally as coefficient maps.
+ *
+ * @param polys - Array of polynomial expression strings
+ * @param vars - Variable names
+ * @returns Array of Groebner basis polynomial strings
+ *
+ * @example
+ * groebnerBasis(['x^2 + y - 1', 'x + y^2 - 1'], ['x', 'y'])
+ */
+export declare function groebnerBasis(polys: string[], vars: string[]): string[];
+/**
+ * Compute the minimal polynomial of a numerical algebraic expression.
+ *
+ * Given a numerical value (expressed as a string that evaluates to a number),
+ * attempts to find a polynomial with integer coefficients that has this
+ * value as a root.
+ *
+ * Uses the LLL-like approach of checking polynomials of increasing degree.
+ *
+ * @param expr - Expression string that evaluates to a number
+ * @param varName - Variable name for the resulting polynomial
+ * @returns Minimal polynomial as a string, or null if not found
+ *
+ * @example
+ * minimalPolynomial('sqrt(2)', 'x')  // => 'x^2 - 2'
+ * minimalPolynomial('1.618033988749895', 'x') // => 'x^2 - x - 1' (golden ratio)
+ */
+export declare function minimalPolynomial(expr: string, varName: string): string | null;
+/**
+ * Express a polynomial solution in radical form.
+ *
+ * Applies the quadratic formula, Cardano's formula (cubic), and
+ * Ferrari's method (quartic) to express roots using radicals.
+ *
+ * @param expr - Polynomial expression string (set equal to 0)
+ * @returns Array of root expressions in radical form
+ *
+ * @example
+ * toRadicals('x^2 - 2')  // => ['sqrt(2)', '-sqrt(2)']
+ * toRadicals('x^2 + x - 1') // => ['(-1 + sqrt(5))/2', '(-1 - sqrt(5))/2']
+ */
+export declare function toRadicals(expr: string): string[];
+/**
+ * Construct a piecewise function.
+ *
+ * Returns a function that evaluates the appropriate expression based
+ * on the condition that is satisfied.
+ *
+ * @param conditions - Array of condition expression strings
+ * @param values - Array of value expression strings (one more than conditions for default)
+ * @returns A function that evaluates the piecewise expression
+ *
+ * @example
+ * const f = piecewise(
+ *   ['x < 0', 'x >= 0'],
+ *   ['-x', 'x']
+ * );
+ * f({ x: -3 }); // => 3
+ * f({ x: 5 });  // => 5
+ */
+export declare function piecewise(conditions: string[], values: string[]): (scope: Record<string, f64>) => f64;
+/**
+ * Solve an ordinary differential equation.
+ *
+ * Handles separable and linear first/second-order ODEs numerically
+ * using the Runge-Kutta 4th order method.
+ *
+ * For an ODE dy/dx = f(x, y), returns solution values at specified points.
+ *
+ * @param ode - Right-hand side expression f(x, y) where dy/dx = f(x, y)
+ * @param y - Dependent variable name
+ * @param x - Independent variable name
+ * @param x0 - Initial x value
+ * @param y0 - Initial y value (or [y0, dy0] for 2nd order)
+ * @param xEnd - End x value
+ * @param steps - Number of steps (default 100)
+ * @returns Array of {x, y} points
+ *
+ * @example
+ * odeGeneral('y', 'y', 'x', 0, 1, 1, 100) // dy/dx = y, y(0)=1 => e^x
+ */
+export declare function odeGeneral(ode: string, y: string, x: string, x0: f64, y0: f64, xEnd: f64, steps?: number): Array<{
+    x: f64;
+    y: f64;
+}>;
+/**
+ * Compute the curl of a 3D vector field.
+ *
+ * curl(F) = (dF3/dy - dF2/dz, dF1/dz - dF3/dx, dF2/dx - dF1/dy)
+ *
+ * @param exprs - Three expression strings [F1, F2, F3]
+ * @param vars - Three variable names [x, y, z]
+ * @param scope - Point at which to evaluate
+ * @returns Three-element array [curl_x, curl_y, curl_z]
+ *
+ * @example
+ * // F = (y, -x, 0), curl = (0, 0, -2)
+ * curl(['y', '-x', '0'], ['x', 'y', 'z'], { x: 0, y: 0, z: 0 })
+ * // => [0, 0, -2]
+ */
+export declare function curl(exprs: string[], vars: string[], scope: Record<string, f64>): [f64, f64, f64];
+/**
+ * Compute the inverse Laplace transform using a lookup table of known transform pairs.
+ *
+ * Given an expression F(s) in the s-domain, returns the time-domain
+ * function f(t) by matching known Laplace transform pairs numerically.
+ *
+ * Supported patterns:
+ *   - 1/s               → 1          (unit step)
+ *   - 1/s^2             → t          (ramp)
+ *   - c/s^n             → c * t^(n-1) / (n-1)!  (power)
+ *   - 1/(s - a)         → e^(at)     (exponential)
+ *   - c/(s - a)         → c * e^(at) (scaled exponential)
+ *   - s/(s^2 + b^2)     → cos(b*t)
+ *   - b/(s^2 + b^2)     → sin(b*t)
+ *   - s/(s^2 - a^2)     → cosh(a*t)
+ *   - a/(s^2 - a^2)     → sinh(a*t)
+ *
+ * For sums/differences, each term is transformed independently.
+ *
+ * @param expr - Expression in the s-domain (string or parsed Node)
+ * @param sVar - Name of the s-domain variable (default: 's')
+ * @param tVar - Name of the time variable (default: 't')
+ * @returns Time-domain expression as a string
+ *
+ * @example
+ * inverseLaplaceTransform('1/s', 's', 't')          // => '1'
+ * inverseLaplaceTransform('1/s^2', 's', 't')        // => 't'
+ * inverseLaplaceTransform('1/(s - 2)', 's', 't')    // => 'e^(2 * t)'
+ * inverseLaplaceTransform('s/(s^2 + 4)', 's', 't')  // => 'cos(2 * t)'
+ * inverseLaplaceTransform('2/(s^2 + 4)', 's', 't')  // => 'sin(2 * t)'
+ */
+export declare function inverseLaplaceTransform(expr: string | MathNode, sVar?: string, tVar?: string): string;
+/**
+ * Batch fan-out threshold.
+ *
+ * Arrays of length ≥ CAS_BATCH_THRESHOLD are processed via the compute pool
+ * worker fan-out.  Below the threshold the expressions are processed in-process
+ * with a simple loop (still async for a uniform call signature).
+ */
+export declare const CAS_BATCH_THRESHOLD = 16;
+/**
+ * Simplify a single expression (CAS batch-capable variant).
+ *
+ * Named `casSimplify` to avoid ambiguity with the factory-generated
+ * `simplify` from the mathjs compatibility layer.  Both perform algebraic
+ * simplification; this one uses string-level pattern matching and supports
+ * a batch-array overload with worker fan-out for large inputs.
+ *
+ * @param expr - Expression string or parsed MathNode
+ * @returns Simplified expression string
+ *
+ * @example
+ * casSimplify('x + x')   // => '2*x'
+ * casSimplify('1*y')     // => 'y'
+ * casSimplify('2 * 3')   // => '6'
+ */
+export declare function casSimplify(expr: string | MathNode): string;
+/**
+ * Simplify an array of expressions (batch overload with worker fan-out).
+ *
+ * Arrays shorter than {@link CAS_BATCH_THRESHOLD} (16) are processed
+ * synchronously in-process and the promise resolves immediately.
+ * Longer arrays are dispatched to the worker pool — each expression is
+ * shipped as a source string, the worker applies the same string-level
+ * simplification rules, and the results are returned as strings.
+ *
+ * **String round-trip:** batch inputs are serialised to their source string,
+ * processed in the worker, and the result strings are returned.  Parsed
+ * `MathNode` inputs are converted to strings via `.toString()` before
+ * dispatch.
+ *
+ * @param exprs - Array of expression strings (or MathNodes)
+ * @returns Promise resolving to an array of simplified expression strings
+ *
+ * @example
+ * // Below threshold — resolved synchronously
+ * await casSimplify(['x + x', 'y * 1', '2 * 3'])
+ * // => ['2*x', 'y', '6']
+ *
+ * // Above threshold — worker fan-out
+ * await casSimplify(Array.from({ length: 32 }, (_, i) => `${i}*x + ${i}*x`))
+ */
+export declare function casSimplify(exprs: Array<string | MathNode>): Promise<string[]>;
+/**
+ * Compute the symbolic derivative of a single expression (CAS batch-capable variant).
+ *
+ * Named `casDerivative` to avoid ambiguity with the factory-generated
+ * `derivative` from the mathjs compatibility layer.
+ *
+ * Uses power rule, trig (sin/cos), exp, and ln patterns.  Unrecognised terms
+ * are left as `d/d<variable>(<term>)` placeholders.
+ *
+ * @param expr - Expression string or parsed MathNode
+ * @param variable - Variable to differentiate with respect to
+ * @returns Derivative expression string
+ *
+ * @example
+ * casDerivative('x^2', 'x')   // => '2*x^1'
+ * casDerivative('sin(x)', 'x') // => 'cos(x)'
+ * casDerivative('exp(x)', 'x') // => 'exp(x)'
+ */
+export declare function casDerivative(expr: string | MathNode, variable: string): string;
+/**
+ * Compute the symbolic derivative of an array of expressions (batch overload).
+ *
+ * Arrays shorter than {@link CAS_BATCH_THRESHOLD} (16) are processed
+ * synchronously in-process.  Longer arrays are dispatched to the worker pool.
+ *
+ * **String round-trip:** batch inputs are serialised to their source string
+ * before dispatch.
+ *
+ * @param exprs - Array of expression strings (or MathNodes)
+ * @param variable - Variable to differentiate with respect to
+ * @returns Promise resolving to an array of derivative expression strings
+ *
+ * @example
+ * await casDerivative(['x^2', 'sin(x)', 'exp(x)'], 'x')
+ * // => ['2*x^1', 'cos(x)', 'exp(x)']
+ */
+export declare function casDerivative(exprs: Array<string | MathNode>, variable: string): Promise<string[]>;
+/**
+ * Expand a single expression by distributing products over sums
+ * (CAS batch-capable variant).
+ *
+ * Named `casExpand` to avoid ambiguity with the `expand` function in
+ * `algebra.ts`.  Both perform algebraic expansion; this one additionally
+ * supports a batch-array overload with worker fan-out for large inputs.
+ *
+ * @param expr - Expression string or parsed MathNode
+ * @returns Expanded expression string
+ *
+ * @example
+ * casExpand('(x+1)^2')    // => 'x*x + x*1 + 1*x + 1*1'
+ * casExpand('(a+b)*(a-b)') // distributes fully
+ */
+export declare function casExpand(expr: string | MathNode): string;
+/**
+ * Expand an array of expressions (batch overload with worker fan-out).
+ *
+ * Arrays shorter than {@link CAS_BATCH_THRESHOLD} (16) are processed
+ * synchronously in-process.  Longer arrays are dispatched to the worker pool.
+ *
+ * **String round-trip:** batch inputs are serialised to their source string
+ * before dispatch.
+ *
+ * @param exprs - Array of expression strings (or MathNodes)
+ * @returns Promise resolving to an array of expanded expression strings
+ *
+ * @example
+ * await casExpand(['(x+1)^2', '(a+b)^3'])
+ */
+export declare function casExpand(exprs: Array<string | MathNode>): Promise<string[]>;
+/**
+ * Factor a single expression by extracting the integer GCD from all terms
+ * (CAS batch-capable variant).
+ *
+ * Named `casFactor` to avoid ambiguity with the `factor` function in
+ * `algebra.ts`.  Both factor expressions; this one additionally supports a
+ * batch-array overload with worker fan-out for large inputs.
+ *
+ * Returns the original expression unchanged when no common integer factor
+ * greater than 1 is found, or when terms do not follow the `c*var` pattern.
+ *
+ * @param expr - Expression string or parsed MathNode
+ * @returns Factored expression string
+ *
+ * @example
+ * casFactor('2*x + 4*y')  // => '2*(x + 2*y)'
+ * casFactor('x^2 - 1')    // => 'x^2 - 1'  (no integer GCD > 1)
+ */
+export declare function casFactor(expr: string | MathNode): string;
+/**
+ * Factor an array of expressions (batch overload with worker fan-out).
+ *
+ * Arrays shorter than {@link CAS_BATCH_THRESHOLD} (16) are processed
+ * synchronously in-process.  Longer arrays are dispatched to the worker pool.
+ *
+ * **String round-trip:** batch inputs are serialised to their source string
+ * before dispatch.
+ *
+ * @param exprs - Array of expression strings (or MathNodes)
+ * @returns Promise resolving to an array of factored expression strings
+ *
+ * @example
+ * await casFactor(['2*x + 4*y', '3*a + 6*b'])
+ */
+export declare function casFactor(exprs: Array<string | MathNode>): Promise<string[]>;
+export {};
+//# sourceMappingURL=cas.d.ts.map