@cortex-js/compute-engine 0.32.0 → 0.33.0

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

@@ -0,0 +1,116 @@
+/* 0.33.0 */
+ *
+ * ## THEORY OF OPERATIONS
+ *
+ * A numeric value represents a number literal.
+ *
+ * It is defined as a functional field over the complex numbers.
+ *
+ * It includes basic arithmetic operations: addition, subtraction,
+ * multiplication, power, division, negation, inversion, square root.
+ *
+ * Several flavors of numeric values are available:
+ * - `NumericValue` is the base class for all numeric values.
+ * - `ExactNumericValue` is a numeric value that represents numbers as the
+ *    sum of an imaginary number and the product of a rational and a radical
+ *    (square root of a integer).
+ * - `BigNumericValue` is a numeric value that represents numbers as the
+ *   sum of an imaginary number and a decimal (arbitrary precision) number.
+ *
+ * An exact numeric value may need to be converted to a float one, for
+ *   example when calculating the square root of a square root.
+ *
+ * A float numeric value is never converted to an exact one.
+ *
+ */
+import { Decimal } from 'decimal.js';
+import type { Rational, SmallInteger } from '../numerics/types';
+import { NumericPrimitiveType } from '../../common/type/types';
+export type BigNumFactory = (value: Decimal.Value) => Decimal;
+/** The value is equal to `(decimal * rational * sqrt(radical)) + im * i`
+ * @category Numerics */
+export type ExactNumericValueData = {
+    rational?: Rational;
+    radical?: number;
+};
+/** @category Numerics */
+export type NumericValueData = {
+    re?: Decimal | number;
+    im?: number;
+};
+/** @category Numerics */
+export type NumericValueFactory = (data: number | Decimal | NumericValueData) => NumericValue;
+/** @category Numerics */
+export declare abstract class NumericValue {
+    abstract get type(): NumericPrimitiveType;
+    /** True if numeric value is the product of a rational and the square root of an integer.
+     *
+     * This includes: 3/4√5, -2, √2, etc...
+     *
+     * But it doesn't include 0.5, 3.141592, etc...
+     *
+     */
+    abstract get isExact(): boolean;
+    /** If `isExact()`, returns an ExactNumericValue, otherwise returns undefined.
+     */
+    abstract get asExact(): NumericValue | undefined;
+    /** The real part of this numeric value.
+     *
+     * Can be negative, 0 or positive.
+     */
+    abstract get re(): number;
+    /**  bignum version of .re, if available */
+    get bignumRe(): Decimal | undefined;
+    /** The imaginary part of this numeric value.
+     *
+     * Can be negative, zero or positive.
+     */
+    im: number;
+    get bignumIm(): Decimal | undefined;
+    abstract get numerator(): NumericValue;
+    abstract get denominator(): NumericValue;
+    abstract get isNaN(): boolean;
+    abstract get isPositiveInfinity(): boolean;
+    abstract get isNegativeInfinity(): boolean;
+    abstract get isComplexInfinity(): boolean;
+    abstract get isZero(): boolean;
+    isZeroWithTolerance(_tolerance: number | Decimal): boolean;
+    abstract get isOne(): boolean;
+    abstract get isNegativeOne(): boolean;
+    /** The sign of complex numbers is undefined */
+    abstract sgn(): -1 | 0 | 1 | undefined;
+    /** Return a non-exact representation of the numeric value */
+    abstract N(): NumericValue;
+    abstract neg(): NumericValue;
+    abstract inv(): NumericValue;
+    abstract add(other: number | NumericValue): NumericValue;
+    abstract sub(other: NumericValue): NumericValue;
+    abstract mul(other: number | Decimal | NumericValue): NumericValue;
+    abstract div(other: SmallInteger | NumericValue): NumericValue;
+    abstract pow(n: number | NumericValue | {
+        re: number;
+        im: number;
+    }): NumericValue;
+    abstract root(n: number): NumericValue;
+    abstract sqrt(): NumericValue;
+    abstract gcd(other: NumericValue): NumericValue;
+    abstract abs(): NumericValue;
+    abstract ln(base?: number): NumericValue;
+    abstract exp(): NumericValue;
+    abstract floor(): NumericValue;
+    abstract ceil(): NumericValue;
+    abstract round(): NumericValue;
+    abstract eq(other: number | NumericValue): boolean;
+    abstract lt(other: number | NumericValue): boolean | undefined;
+    abstract lte(other: number | NumericValue): boolean | undefined;
+    abstract gt(other: number | NumericValue): boolean | undefined;
+    abstract gte(other: number | NumericValue): boolean | undefined;
+    /** Object.valueOf(): returns a primitive value, preferably a JavaScript
+     *  number over a string, even if at the expense of precision */
+    valueOf(): number | string;
+    /** Object.toPrimitive() */
+    [Symbol.toPrimitive](hint: 'number' | 'string' | 'default'): number | string | null;
+    /** Object.toJSON */
+    toJSON(): any;
+    print(): void;
+}

package/dist/types/compute-engine/numerics/bigint.d.ts

@@ -0,0 +1,2 @@
+/* 0.33.0 */
+export declare function bigint(a: Decimal | number | bigint | string): bigint | null;

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

@@ -0,0 +1,4 @@
+/* 0.33.0 */
+export declare function bigintValue(expr: Expression | null | undefined): bigint | null;
+/** Output a shorthand if possible */
+export declare function numberToExpression(num: number | bigint, fractionalDigits?: string | number): Expression;

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

@@ -0,0 +1,12 @@
+/* 0.33.0 */
+/** An interval is a continuous set of real numbers */
+export type Interval = {
+    start: number;
+    openStart: boolean;
+    end: number;
+    openEnd: boolean;
+};
+export declare function interval(expr: BoxedExpression): Interval | undefined;
+export declare function intervalContains(int: Interval, val: number): boolean;
+/** Return true if int1 is a subset of int2 */
+export declare function intervalSubset(int1: Interval, int2: Interval): boolean;

package/dist/types/compute-engine/numerics/monte-carlo.d.ts

@@ -0,0 +1,4 @@
+/* 0.33.0 */
+    estimate: number;
+    error: number;
+};

package/dist/types/compute-engine/numerics/numeric-bigint.d.ts

@@ -0,0 +1,18 @@
+/* 0.33.0 */
+export declare function lcm(a: bigint, b: bigint): bigint;
+/** Return `[factor, root]` such that
+ * pow(n, 1/exponent) = factor * pow(root, 1/exponent)
+ *
+ * canonicalInteger(75, 2) -> [5, 3] = 5^2 * 3
+ *
+ */
+export declare function canonicalInteger(n: bigint, exponent: number): [factor: bigint, root: bigint];
+export declare function reducedInteger(n: bigint): bigint | number;
+/**
+ * Computes the factorial of a number as a generator to allow interruptibility.
+ * Yields intermediate values periodically, but these are not intended to be the primary result.
+ *
+ * @param n - The number to compute the factorial of (as a BigInt).
+ * @returns A generator that can be iterated for intermediate values, with the final value returned when the computation completes.
+ */
+export declare function factorial(n: bigint): Generator<bigint, bigint>;

package/dist/types/compute-engine/numerics/numeric-bignum.d.ts

@@ -0,0 +1,9 @@
+/* 0.33.0 */
+export declare function gcd(a: BigNum, b: BigNum): BigNum;
+export declare function lcm(a: BigNum, b: BigNum): BigNum;
+export declare function factorial2(ce: IBigNum, n: BigNum): BigNum;
+/**
+ * If the exponent of the bignum is in the range of the exponents
+ * for machine numbers,return true.
+ */
+export declare function isInMachineRange(d: BigNum): boolean;

package/dist/types/compute-engine/numerics/numeric-complex.d.ts

@@ -0,0 +1,3 @@
+/* 0.33.0 */
+export declare function gamma(c: Complex): Complex;
+export declare function gammaln(c: Complex): Complex;

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

@@ -0,0 +1,60 @@
+/* 0.33.0 */
+export declare const MACHINE_PRECISION_BITS = 53;
+export declare const MACHINE_PRECISION: number;
+export declare const DEFAULT_TOLERANCE = 1e-10;
+export declare const SMALL_INTEGER = 1000000;
+/** The largest number of digits of a bigint */
+export declare const MAX_BIGINT_DIGITS = 1024;
+export declare const MAX_ITERATION = 10000;
+export declare const MAX_SYMBOLIC_TERMS = 200;
+/**
+ * Returns the smallest floating-point number greater than x.
+ * Denormalized values may not be supported.
+ */
+export declare function nextUp(x: number): number;
+export declare function nextDown(x: number): number;
+/** Return `[factor, root]` such that
+ * pow(n, 1/exponent) = factor * pow(root, 1/exponent)
+ *
+ * canonicalInteger(75, 2) -> [5, 3] = 5^2 * 3
+ *
+ */
+export declare function canonicalInteger(n: number, exponent: number): readonly [factor: number, root: number];
+export declare function gcd(a: number, b: number): number;
+export declare function lcm(a: number, b: number): number;
+export declare function factorial(n: number): number;
+export declare function factorial2(n: number): number;
+export declare function chop(n: number, tolerance?: number): 0 | number;
+/**
+ * An 8th-order centered difference approximation can be used to get a highly
+ * accurate approximation of the first derivative of a function.
+ * The formula for the 8th-order centered difference approximation for the
+ * first derivative is given by:
+ *
+ * $$ f'(x) \approx \frac{1}{280h} \left[ -f(x-4h) + \frac{4}{3}f(x-3h) - \frac{1}{5}f(x-2h) + \frac{8}{5}f(x-h) - \frac{8}{5}f(x+h) + \frac{1}{5}f(x+2h) - \frac{4}{3}f(x+3h) + f(x+4h) \right]$$
+ *
+ * Note: Mathematica uses an 8th order approximation for the first derivative
+ *
+ * f: the function
+ * x: the point at which to approximate the derivative
+ * h: the step size
+ *
+ * See https://en.wikipedia.org/wiki/Finite_difference_coefficient
+ */
+export declare function centeredDiff8thOrder(f: (number: any) => number, x: number, h?: number): number;
+/**
+ *
+ * @param f
+ * @param x
+ * @param dir Direction of approach: > 0 for right, < 0 for left, 0 for both
+ * @returns
+ */
+export declare function limit(f: (x: number) => number, x: number, dir?: number): number;
+export declare function cantorEnumerateRationals(): Generator<[number, number]>;
+export declare function cantorEnumeratePositiveRationals(): Generator<[
+    number,
+    number
+]>;
+export declare function cantorEnumerateComplexNumbers(): Generator<[number, number]>;
+export declare function cantorEnumerateIntegers(): Generator<number>;
+export declare function cantorEnumerateNaturalNumbers(): Generator<number>;

package/dist/types/compute-engine/numerics/primes.d.ts

@@ -0,0 +1,7 @@
+/* 0.33.0 */
+export declare function primeFactors(n: number): {
+    [factor: number]: number;
+};
+export declare function isPrime(n: number): boolean | undefined;
+export declare function isPrimeBigint(n: bigint): boolean | undefined;
+export declare function bigPrimeFactors(d: bigint): Map<bigint, number>;

package/dist/types/compute-engine/numerics/rationals.d.ts

@@ -0,0 +1,43 @@
+/* 0.33.0 */
+export declare function isRational(x: any | null): x is Rational;
+export declare function isMachineRational(x: any | null): x is [SmallInteger, SmallInteger];
+export declare function isBigRational(x: any | null): x is [bigint, bigint];
+export declare function isZero(x: Rational): boolean;
+export declare function isPositive(x: Rational): boolean;
+export declare function isOne(x: Rational): boolean;
+export declare function isNegativeOne(x: Rational): boolean;
+export declare function isInteger(x: Rational): boolean;
+export declare function machineNumerator(x: Rational): number;
+export declare function machineDenominator(x: Rational): number;
+export declare function rationalAsFloat(x: Rational): number;
+export declare function isNeg(x: Rational): boolean;
+export declare function div(lhs: Rational, rhs: Rational): Rational;
+/**
+ * Add a literal numeric value to a rational.
+ * If the rational is a bigint, this is a hint to do the calculation in bigint
+ * (no need to check `bignumPreferred()`).
+ * @param lhs
+ * @param rhs
+ * @returns
+ */
+export declare function add(lhs: Rational, rhs: Rational): Rational;
+export declare function mul(lhs: Rational, rhs: Rational): Rational;
+export declare function neg(x: [SmallInteger, SmallInteger]): [SmallInteger, SmallInteger];
+export declare function neg(x: [bigint, bigint]): [bigint, bigint];
+export declare function neg(x: Rational): Rational;
+export declare function inverse(x: [SmallInteger, SmallInteger]): [SmallInteger, SmallInteger];
+export declare function inverse(x: [bigint, bigint]): [bigint, bigint];
+export declare function inverse(x: Rational): Rational;
+export declare function asMachineRational(r: Rational): [SmallInteger, SmallInteger];
+export declare function pow(r: Rational, exp: SmallInteger): Rational;
+export declare function sqrt(r: Rational): Rational | undefined;
+export declare function rationalGcd(lhs: Rational, rhs: Rational): Rational;
+export declare function reducedRational(r: [SmallInteger, SmallInteger]): [SmallInteger, SmallInteger];
+export declare function reducedRational(r: [bigint, bigint]): [bigint, bigint];
+export declare function reducedRational(r: Rational): Rational;
+/** Return a rational approximation of x */
+export declare function rationalize(x: number): [n: number, d: number] | number;
+/** Return [factor, root] such that factor * sqrt(root) = sqrt(n)
+ * when factor and root are rationals
+ */
+export declare function reduceRationalSquareRoot(n: Rational): [factor: Rational, root: number | bigint];

package/dist/types/compute-engine/numerics/richardson.d.ts

@@ -0,0 +1,80 @@
+/* 0.33.0 */
+
+    Translated from https://github.com/JuliaMath/Richardson.jl/blob/master/src/Richardson.jl
+
+
+    The `Richardson` module provides a function `extrapolate` that
+    extrapolates a given function `f(x)` to `f(x0)`, evaluating
+    `f` only  at a geometric sequence of points `> x0`
+    (or optionally `< x0`).
+    
+    The key algorithm is Richardson extrapolation using a Neville—Aitken
+    tableau, which adaptively increases the degree of an extrapolation
+    polynomial until convergence is achieved to a desired tolerance
+    (or convergence stalls due to e.g. floating-point errors).  This
+    allows one to obtain `f(x0)` to high-order accuracy, assuming
+    that `f(x0+h)` has a Taylor series or some other power
+    series in `h`.
+*/
+export interface ExtrapolateOptions {
+    contract?: number;
+    step?: number;
+    power?: number;
+    atol?: number;
+    rtol?: number;
+    maxeval?: number;
+    breaktol?: number;
+}
+/**
+ *
+ * Extrapolate `f(x)` to `f₀ ≈ f(x0)`, evaluating `f` only at `x > x0` points
+(or `x < x0` if `h < 0`) using Richardson extrapolation starting at
+`x=x₀+h`.  It returns a tuple `(f₀, err)` of the estimated `f(x0)`
+and an error estimate.
+
+The return value of `f` can be any type supporting `±` and `norm`
+operations (i.e. a normed vector space).
+Similarly, `h` and `x0` can be in any normed vector space,
+in which case `extrapolate` performs Richardson extrapolation
+of `f(x0+s*h)` to `s=0⁺` (i.e. it takes the limit as `x` goes
+to `x0` along the `h` direction).
+
+On each step of Richardson extrapolation, it shrinks `x-x0` by
+a factor of `contract`, stopping when the estimated error is
+`< max(rtol*norm(f₀), atol)`, when the estimated error
+increases by more than `breaktol` (e.g. due to numerical errors in the
+computation of `f`), when `f` returns a non-finite value (`NaN` or `Inf`),
+ or when `f` has been evaluated `maxeval` times.   Note that
+if the function may converge to zero, you may want
+specify a nonzero `atol` (which cannot be set by default
+because it depends on the scale/units of `f`); alternatively,
+in such cases `extrapolate` will halt when it becomes
+limited by the floating-point precision.   (Passing `breaktol=Inf`
+can be useful to force `extrapolate` to continue shrinking `h` even
+if polynomial extrapolation is initially failing to converge,
+possibly at the cost of extraneous function evaluations.)
+
+
+If `x0 = ±∞` (`±Inf`), then `extrapolate` computes the limit of
+`f(x)` as `x ⟶ ±∞` using geometrically *increasing* values
+of `h` (by factors of `1/contract`).
+
+In general, the starting `h` should be large enough that `f(x0+h)`
+can be computed accurately and efficiently (e.g. without
+severe cancellation errors), but small enough that `f` does not
+oscillate much between `x0` and `h`.  i.e. `h` should be a typical
+scale over which the function `f` varies significantly.
+
+Technically, Richardson extrapolation assumes that `f(x0+h)` can
+be expanded in a power series in `h^power`, where the default
+`power=1` corresponds to an ordinary Taylor series (i.e. assuming
+`f` is analytic at `x0`).  If this is not true, you may obtain
+slow convergence from `extrapolate`, but you can pass a different
+value of `power` (e.g. `power=0.5`) if your `f` has some different
+(Puiseux) power-series expansion.   Conversely, if `f` is
+an *even* function around `x0`, i.e. `f(x0+h) == f(x0-h)`,
+so that its Taylor series contains only *even* powers of `h`,
+you can accelerate convergence by passing `power=2`.
+
+ */
+export declare function extrapolate(f: (x: number) => number, x0: number, options?: ExtrapolateOptions): [val: number, err: number];

package/dist/types/compute-engine/numerics/special-functions.d.ts

@@ -0,0 +1,28 @@
+/* 0.33.0 */
+import type { BigNum } from './types';
+export declare function gammaln(z: number): number;
+export declare function gamma(z: number): number;
+/**
+ * Inverse Error Function.
+ *
+ */
+export declare function erfInv(x: number): number;
+/**
+ * Trivial function, used when compiling.
+ */
+export declare function erfc(x: number): number;
+/**
+ * An approximation of the gaussian error function, Erf(), using
+ * Abramowitz and Stegun approximation.
+ *
+ * Thoughts for future improvements:
+ * - https://math.stackexchange.com/questions/321569/approximating-the-error-function-erf-by-analytical-functions
+ * - https://en.wikipedia.org/wiki/Error_function#Approximation_with_elementary_functions
+
+ *
+ * References:
+ * - NIST: https://dlmf.nist.gov/7.24#i
+ */
+export declare function erf(x: number): number;
+export declare function bigGammaln(ce: ComputeEngine, z: BigNum): BigNum;
+export declare function bigGamma(ce: ComputeEngine, z: BigNum): BigNum;

package/dist/types/compute-engine/numerics/statistics.d.ts

@@ -0,0 +1,24 @@
+/* 0.33.0 */
+import type { BigNum } from './types';
+export declare function mean(values: Iterable<number>): number;
+export declare function bigMean(bignum: BigNumFactory, values: Iterable<BigNum>): BigNum;
+export declare function median(values: Iterable<number>): number;
+export declare function bigMedian(values: Iterable<BigNum>): BigNum;
+export declare function variance(values: Iterable<number>): number;
+export declare function bigVariance(bignum: BigNumFactory, values: Iterable<BigNum>): BigNum;
+export declare function populationVariance(values: Iterable<number>): number;
+export declare function bigPopulationVariance(bignum: BigNumFactory, values: Iterable<BigNum>): BigNum;
+export declare function standardDeviation(values: Iterable<number>): number;
+export declare function bigStandardDeviation(bignum: BigNumFactory, values: Iterable<BigNum>): BigNum;
+export declare function populationStandardDeviation(values: Iterable<number>): number;
+export declare function bigPopulationStandardDeviation(bignum: BigNumFactory, values: Iterable<BigNum>): BigNum;
+export declare function kurtosis(values: Iterable<number>): number;
+export declare function bigKurtosis(bignum: BigNumFactory, values: Iterable<BigNum>): BigNum;
+export declare function skewness(values: Iterable<number>): number;
+export declare function bigSkewness(bignum: BigNumFactory, values: Iterable<BigNum>): BigNum;
+export declare function mode(values: Iterable<number>): number;
+export declare function bigMode(bignum: BigNumFactory, values: Iterable<BigNum>): BigNum;
+export declare function quartiles(values: Iterable<number>): [number, number, number];
+export declare function bigQuartiles(values: Iterable<BigNum>): [BigNum, BigNum, BigNum];
+export declare function interquartileRange(values: Iterable<number>): number;
+export declare function bigInterquartileRange(values: Iterable<BigNum>): BigNum;

package/dist/types/compute-engine/numerics/strings.d.ts

@@ -0,0 +1,2 @@
+/* 0.33.0 */
+export declare function numberToString(num: number | bigint, fractionalDigits?: number | string): string;

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

@@ -0,0 +1,31 @@
+/* 0.33.0 */
+/** @internal */
+type IsInteger<N extends number> = `${N}` extends `${string}.${string}` ? never : `${N}` extends `-${string}.${string}` ? never : number;
+/** A `SmallInteger` is an integer < 1e6
+ * @category Numerics
+ */
+export type SmallInteger = IsInteger<number>;
+/**
+ * A rational number is a number that can be expressed as the quotient or fraction p/q of two integers,
+ * a numerator p and a non-zero denominator q.
+ *
+ * A rational can either be represented as a pair of small integers or
+ * a pair of big integers.
+ *
+ * @category Numerics
+ */
+export type Rational = [SmallInteger, SmallInteger] | [bigint, bigint];
+/** @category Numerics */
+export type BigNum = Decimal;
+/** @category Numerics */
+export interface IBigNum {
+    readonly _BIGNUM_NAN: BigNum;
+    readonly _BIGNUM_ZERO: BigNum;
+    readonly _BIGNUM_ONE: BigNum;
+    readonly _BIGNUM_TWO: BigNum;
+    readonly _BIGNUM_HALF: BigNum;
+    readonly _BIGNUM_PI: BigNum;
+    readonly _BIGNUM_NEGATIVE_ONE: BigNum;
+    bignum(value: string | number | bigint | BigNum): BigNum;
+}
+export {};

package/dist/types/compute-engine/symbolic/antiderivative.d.ts

@@ -0,0 +1,3 @@
+/* 0.33.0 */
+/** Calculate the antiderivative of fn, as an expression (not a function) */
+export declare function antiderivative(fn: BoxedExpression, index: string): BoxedExpression;

package/dist/types/compute-engine/symbolic/derivative.d.ts

@@ -0,0 +1,18 @@
+/* 0.33.0 */
+/**
+ *
+ * @param fn The function to differentiate, a function literal.
+ *
+ * @returns a function expression representing the derivative of `fn` with
+ * respect to the variables in `degrees`.
+ */
+export declare function derivative(fn: BoxedExpression, order: number): BoxedExpression | undefined;
+/**
+ * Calculate the partial derivative of an expression with respect to a
+ * variable, `v`.
+ *
+ * All expressions that do not explicitly depend on `v` are taken to have zero
+ * partial derivative.
+ *
+ */
+export declare function differentiate(expr: BoxedExpression, v: string): BoxedExpression | undefined;

package/dist/types/compute-engine/symbolic/distribute.d.ts

@@ -0,0 +1,5 @@
+/* 0.33.0 */
+/**
+ *
+ */
+export declare function distribute(expr: BoxedExpression, g?: string, f?: string): BoxedExpression;

package/dist/types/compute-engine/symbolic/fu-cost.d.ts

@@ -0,0 +1,33 @@
+/* 0.33.0 */
+ * Cost functions for the Fu trigonometric simplification algorithm.
+ *
+ * The primary objective is to minimize the number of trigonometric functions,
+ * with secondary consideration for overall expression complexity.
+ */
+import type { BoxedExpression } from '../global-types';
+/**
+ * Count the number of trigonometric function occurrences in an expression.
+ * This is the primary metric for the Fu algorithm.
+ */
+export declare function countTrigFunctions(expr: BoxedExpression): number;
+/**
+ * Count the number of leaves (atoms) in an expression.
+ * Includes symbols, numbers, and function names.
+ */
+export declare function countLeaves(expr: BoxedExpression): number;
+/**
+ * The default trig cost function for the Fu algorithm.
+ *
+ * Priority:
+ * 1. Minimize number of trig functions (weighted heavily)
+ * 2. Minimize leaf count (secondary)
+ *
+ * This ensures that expressions with fewer trig functions are always
+ * preferred, even if they have slightly more total operations.
+ */
+export declare function trigCost(expr: BoxedExpression): number;
+export type TrigCostFunction = (expr: BoxedExpression) => number;
+/**
+ * Default cost function for the Fu algorithm
+ */
+export declare const DEFAULT_TRIG_COST: TrigCostFunction;

package/dist/types/compute-engine/symbolic/fu-transforms.d.ts

@@ -0,0 +1,130 @@
+/* 0.33.0 */
+ * Fu Algorithm Transformation Rules
+ *
+ * Programmatic implementations of TR1-TR22 from the Fu trigonometric
+ * simplification algorithm.
+ *
+ * Reference: Fu, Hongguang, Xiuqin Zhong, and Zhenbing Zeng.
+ * "Automated and readable simplification of trigonometric expressions."
+ * Mathematical and Computer Modelling 44.11 (2006): 1169-1177.
+ *
+ * Each TR function applies a specific transformation to an expression.
+ * Returns the transformed expression, or undefined if the rule doesn't apply.
+ *
+ * IMPORTANT: These functions should NOT call .simplify() on their results
+ * to avoid infinite recursion when called from the simplification pipeline.
+ */
+import type { BoxedExpression } from '../global-types';
+/**
+ * Check if an expression contains any trigonometric functions
+ */
+export declare function hasTrigFunction(expr: BoxedExpression): boolean;
+/**
+ * Check if expression contains specific operators anywhere in the tree
+ */
+export declare function hasOperator(expr: BoxedExpression, ...ops: string[]): boolean;
+export declare function TR1(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR1 to all subexpressions
+ */
+export declare function applyTR1(expr: BoxedExpression): BoxedExpression;
+export declare function TR2(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR2 to all subexpressions
+ */
+export declare function applyTR2(expr: BoxedExpression): BoxedExpression;
+export declare function TR2i(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR2i to all subexpressions
+ */
+export declare function applyTR2i(expr: BoxedExpression): BoxedExpression;
+export declare function TR3(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR3 to all subexpressions
+ */
+export declare function applyTR3(expr: BoxedExpression): BoxedExpression;
+export declare function TR5(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR5 to all subexpressions
+ */
+export declare function applyTR5(expr: BoxedExpression): BoxedExpression;
+export declare function TR6(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR6 to all subexpressions
+ */
+export declare function applyTR6(expr: BoxedExpression): BoxedExpression;
+export declare function TR7(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR7 to all subexpressions
+ */
+export declare function applyTR7(expr: BoxedExpression): BoxedExpression;
+export declare function TR7i(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR7i to all subexpressions
+ */
+export declare function applyTR7i(expr: BoxedExpression): BoxedExpression;
+export declare function TR8(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR8 to all subexpressions
+ */
+export declare function applyTR8(expr: BoxedExpression): BoxedExpression;
+export declare function TR9(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR9 to all subexpressions
+ */
+export declare function applyTR9(expr: BoxedExpression): BoxedExpression;
+export declare function TR10(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR10 to all subexpressions
+ */
+export declare function applyTR10(expr: BoxedExpression): BoxedExpression;
+export declare function TR10i(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR10i to all subexpressions
+ */
+export declare function applyTR10i(expr: BoxedExpression): BoxedExpression;
+export declare function TR11(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR11 to all subexpressions
+ */
+export declare function applyTR11(expr: BoxedExpression): BoxedExpression;
+export declare function TR11i(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR11i to all subexpressions
+ */
+export declare function applyTR11i(expr: BoxedExpression): BoxedExpression;
+export declare function TR12(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR12 to all subexpressions
+ */
+export declare function applyTR12(expr: BoxedExpression): BoxedExpression;
+export declare function TR12i(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR12i to all subexpressions
+ */
+export declare function applyTR12i(expr: BoxedExpression): BoxedExpression;
+export declare function TR13(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR13 to all subexpressions
+ */
+export declare function applyTR13(expr: BoxedExpression): BoxedExpression;
+export declare function TR22(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR22 to all subexpressions
+ */
+export declare function applyTR22(expr: BoxedExpression): BoxedExpression;
+export declare function TR22i(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR22i to all subexpressions
+ */
+export declare function applyTR22i(expr: BoxedExpression): BoxedExpression;
+export declare function TRmorrie(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TRmorrie to all subexpressions
+ */
+export declare function applyTRmorrie(expr: BoxedExpression): BoxedExpression;
+export declare function TRpythagorean(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TRpythagorean to all subexpressions
+ */
+export declare function applyTRpythagorean(expr: BoxedExpression): BoxedExpression;