nerdamer 1.1.13 → 2.0.0-rc.1

package/output/core/functions/expand/expand.d.ts

@@ -0,0 +1,42 @@
+import { Expression } from '../../classes/expression/Expression';
+export declare function powerExpandToArray(variables: string[], power: number): any[][];
+/**
+ * Converts an array of number[] back to its expression form. Given a set of arrays in
+ * the form [[1,1,2], [2,0,1]] and the variables [a, b] it gets converted back to
+ * a*b*2 + (a)^2. At the time of this documentation the brackets are always added for power > 1
+ *
+ * @param row
+ * @param variables
+ * @returns
+ */
+export declare function expandArrayToExpression(row: number[][], variables: string[], multiplier?: string): string;
+/**
+ * Checks to see if a sum or product is expandable.
+ *
+ * @param x
+ */
+export declare function isExpandable(x: Expression): boolean;
+/**
+ * Expands the Expression with integer powers > 1. It does this by first flattening out the expression.
+ * The multiplier and power then become one. This enables us to focus on expanding the power by using
+ * integers. So give (x*y+z*y^6)^2 we substitute x*y for 1*($1)^1 and z*y^6 for 1*($2)^1. We then end up with
+ * 1*($1)^2 + 2*($1*$2)^1 + 1*($2)^2 after which we back substitute to get 1*(x*y)^2 + 2*(x*y*z*y^6)^1 + 1*(z*y^6)^2
+ * and run it through the parser for evaluation.
+ *
+ * @param x
+ */
+export declare function powerExpand(x: Expression): Expression;
+/**
+ * Performs multiplication but expands out the sum.
+ *
+ * @param x
+ * @param y
+ * @returns
+ */
+export declare function sumExpandMultiply(x: Expression, y: Expression): Expression;
+/**
+ * Expands the function by distributing the power and the multiplier whenever possible
+ *
+ * @param x
+ */
+export declare function expand(x: Expression): Expression;

package/output/core/functions/expand/expand.js

@@ -0,0 +1,376 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.powerExpandToArray = powerExpandToArray;
+exports.expandArrayToExpression = expandArrayToExpression;
+exports.isExpandable = isExpandable;
+exports.powerExpand = powerExpand;
+exports.sumExpandMultiply = sumExpandMultiply;
+exports.expand = expand;
+const Expression_1 = require("../../classes/expression/Expression");
+const shortcuts_1 = require("../../classes/expression/shortcuts");
+const constants_1 = require("../../classes/parser/constants");
+function powerExpandToArray(variables, power) {
+    /**
+     * The row will take on the form of [a_power, b_power, ..., coeff]. The polynomial gets
+     * flattened so we'll disregard their powers. We'll let the parser handle that at a later point.
+     * So x^2 + x*y become two flat variables with the value x^2 and x*y but for this example let's
+     * think of a & b. Since the variable is flattened each "term" becomes [0, 0, 1]. We'll construct
+     * a table multiplying out the row and column. For the first iteration the column = row. Our table
+     * becomes something like this
+     * +---+----+----+
+     * |   | a  | b  |
+     * +---+----+----+
+     * | a | aa | ba |
+     * | b | ab | bb |
+     * +---+----+----+
+     */
+    // Constructs the row. You get back the array with zeros and a coefficient of one at the end
+    // Given the expression (a+b) becomes [[0,0,1], [0,0,1]] where representing[[power a, power b, coeff a], [power a, power b, coeff b]]
+    // The powers for each term are zero since they're just the value 1
+    function constructRow() {
+        return variables.map((x, i) => {
+            const row = new Array(variables.length).fill(0);
+            row.push(1);
+            row[i] = 1;
+            return row;
+        });
+    }
+    // We now perform piecewise multiplication incrementing the power each time like values are multiplied.
+    let row = constructRow();
+    for (let n = 0; n < power - 1; n++) {
+        const result = [];
+        for (let i = 0; i < row.length; i++) {
+            for (let j = 0; j < variables.length; j++) {
+                const term = [...row[i]];
+                term[j]++;
+                result.push(term);
+            }
+        }
+        const sumMap = new Map();
+        for (const term of result) {
+            const key = term.slice(0, -1).join(',');
+            const existing = sumMap.get(key);
+            if (existing) {
+                existing[existing.length - 1] += term[term.length - 1];
+            }
+            else {
+                sumMap.set(key, [...term]);
+            }
+        }
+        row = Array.from(sumMap.values());
+    }
+    return row;
+}
+/**
+ * Converts an array of number[] back to its expression form. Given a set of arrays in
+ * the form [[1,1,2], [2,0,1]] and the variables [a, b] it gets converted back to
+ * a*b*2 + (a)^2. At the time of this documentation the brackets are always added for power > 1
+ *
+ * @param row
+ * @param variables
+ * @returns
+ */
+function expandArrayToExpression(row, variables, multiplier) {
+    const termsArray = [];
+    // Put the multiplication in front of the multiplier if provided
+    const m = multiplier ? `${multiplier}*` : '';
+    for (let i = 0; i < row.length; i++) {
+        const term = row[i];
+        const varStringArray = [];
+        // We skip the last element since that's the coefficient
+        for (let j = 0; j < term.length - 1; j++) {
+            const variable = variables[j];
+            const p = term[j];
+            if (p === 1) {
+                varStringArray.push(`(${variable})`);
+            }
+            else if (p !== 0) {
+                varStringArray.push(`(${variable})^${p}`);
+            }
+        }
+        let termsString = varStringArray.join('*');
+        const coeff = term[term.length - 1];
+        if (coeff !== 1) {
+            termsString = `(${coeff})*${termsString}`;
+        }
+        termsArray.push(m + termsString);
+    }
+    return termsArray.join('+');
+}
+/**
+ * Checks to see if a sum or product is expandable.
+ *
+ * @param x
+ */
+function isExpandable(x) {
+    return x.isComplex() || !x.getMultiplier().isOne() || x.value.includes('(') || !x.isLinear();
+}
+/**
+ * Expands the Expression with integer powers > 1. It does this by first flattening out the expression.
+ * The multiplier and power then become one. This enables us to focus on expanding the power by using
+ * integers. So give (x*y+z*y^6)^2 we substitute x*y for 1*($1)^1 and z*y^6 for 1*($2)^1. We then end up with
+ * 1*($1)^2 + 2*($1*$2)^1 + 1*($2)^2 after which we back substitute to get 1*(x*y)^2 + 2*(x*y*z*y^6)^1 + 1*(z*y^6)^2
+ * and run it through the parser for evaluation.
+ *
+ * @param x
+ */
+function powerExpand(x) {
+    let retval = x;
+    if (x.isSum() && x.getPower().isInteger()) {
+        const sgn = x.getPower().sign();
+        const power = x.getPower().abs();
+        const variables = x.elementsArray().map(e => {
+            return e.text();
+        });
+        const multiplier = x.getMultiplier().isOne()
+            ? undefined
+            : (sgn < 0 ? x.getMultiplier().invert() : x.getMultiplier()).text();
+        const termsArray = powerExpandToArray(variables, Number(power));
+        const expression = expandArrayToExpression(termsArray, variables, multiplier);
+        retval = Expression_1.Expression.create(expression);
+        if (sgn === -1) {
+            retval = retval.invert();
+        }
+    }
+    return retval;
+}
+/**
+ * Performs multiplication but expands out the sum.
+ *
+ * @param x
+ * @param y
+ * @returns
+ */
+function sumExpandMultiply(x, y) {
+    // Expand both
+    let retval;
+    if (y.isSum() && !x.isSum()) {
+        retval = sumExpandMultiply(y, x);
+    }
+    // Expand but only if the power is one
+    else if (x.isSum()) {
+        if (!x.isLinear()) {
+            // Expand if the power is not one.
+            x = powerExpand(x);
+        }
+        // Expand if expandable
+        if (x.isLinear()) {
+            retval = (0, shortcuts_1.zero)();
+            x.each(element => {
+                if (isExpandable(element)) {
+                    element = expand(element);
+                }
+                // If either is a sum then call this function recursively
+                if (y.isSum() || element.isSum()) {
+                    retval = retval.plus(sumExpandMultiply(y, element));
+                }
+                else {
+                    const result = y.times(element);
+                    retval = retval.plus(result);
+                }
+            });
+        }
+        // Since it turns out that x is not expandable likely due to it being under the denominator,
+        // we can try to see if y is expandable. We send it back to sumExpandMultiply.
+        // Only swap if y is linear to avoid infinite ping-pong between two non-linear sums.
+        else if (y.isSum() && y.isLinear()) {
+            retval = sumExpandMultiply(y, x);
+        }
+        // Since x cannot be expanded and y is not a linear sum, then multiply and return
+        else {
+            retval = x.times(y);
+        }
+    }
+    else {
+        retval = expand(x).times(expand(y));
+    }
+    return retval;
+}
+/**
+ * Expands the product of expressions. The power gets distributed when expanding.
+ *
+ * @param x
+ * @returns
+ */
+function productExpand(x) {
+    /*
+     * Only expand if needed. This eliminates unnecessary multiplication. Note this this is not an all inclusive tests and contains false positives.
+     * In that case it will just be a wasted effort. The test is performed against x value instead of x.text().
+     * Test to see if:
+     * - It has a element with an integer power.
+     * - It has a scoped multiplier
+     * - Contains a sum
+     */
+    // We start with the multiplier
+    let retval;
+    retval = Expression_1.Expression.fromRational(x.getMultiplier());
+    // Store the power
+    const pow = x.getPower();
+    // Store the check to see if the power is one. If it is then don't raise it
+    const powIsOne = pow.isOne();
+    // Loop through the remaining elements
+    x.each(element => {
+        // The power does not equal one then raise it to that power
+        if (!powIsOne) {
+            element = element.pow(pow);
+        }
+        // Unwrap the elements
+        element = unwrap(element);
+        // Expand it if expandable
+        // if(isExpandable(element)) {
+        element = expand(element);
+        // }
+        // Store the power
+        const power = element.getPower();
+        // If it's a product with a power != 1 then expand otherwise just put it back
+        if (element.isProduct() && power.isInteger() && !power.isOne()) {
+            element.each(subElement => {
+                retval = retval.times(subElement.pow(power));
+            });
+        }
+        // retval may have been multiplied out and become a sum at this point so we need to check
+        // if retval or the element is a sum
+        else if (retval.isSum() || element.isSum()) {
+            retval = sumExpandMultiply(retval, element);
+        }
+        // Otherwise just multiply it out but to check if it's expandable first
+        else {
+            retval = retval.times(element);
+        }
+    });
+    return retval;
+}
+/**
+ * Expands each term of the sum. Expects a fully expanded sum
+ *
+ * @param x
+ * @returns
+ */
+function expandTerms(x) {
+    // Only expand into individual terms if the sum has power 1.
+    // For non-linear sums like (b^2-4*a)^(1/2), we must preserve the outer power.
+    if (!x.isLinear()) {
+        return x;
+    }
+    let retval = (0, shortcuts_1.zero)();
+    x.each(e => {
+        retval = retval.plus(expand(e));
+    });
+    return retval;
+}
+/**
+ * Removes the expression from the `parens` function
+ * @param x
+ * @returns
+ */
+function unwrap(x) {
+    if (x.isFunction(constants_1.WRAP)) {
+        const arg = x.getArguments()[0].pow(x.getPower()).times(x.getMultiplier());
+        return arg;
+    }
+    return x;
+}
+/**
+ * Expands factorials in the form of (an+m)!
+ * @param x
+ * @returns
+ */
+function factorialExpand(x) {
+    const args = x.getArguments();
+    let retval = x;
+    const argElements = args[0].elementsArray().sort((a, _b) => {
+        if (a.isNUM()) {
+            return 1;
+        }
+        return -1;
+    });
+    if (argElements.length === 2) {
+        const a = argElements[0];
+        const b = argElements[1];
+        if (a.isVAR() && a.isLinear() && b.isInteger()) {
+            const p = x.getPower();
+            const iterations = Number(b.getMultiplier().numerator);
+            // Start with the base factorial: fact(a) e.g., fact(2*n)
+            const baseFact = Expression_1.Expression.toFunction(constants_1.FACTORIAL, [a]);
+            retval = baseFact;
+            // Multiply by (a+1) * (a+2) * ... * (a+b)
+            // NOT by fact(a+1) * fact(a+2) * ...
+            for (let i = 1; i <= iterations; i++) {
+                const term = a.plus(i); // (2n+1), (2n+2), etc.
+                retval = retval.times(term); // multiply by the term, not its factorial
+            }
+            retval = retval.pow(p);
+        }
+        else {
+            let t = Expression_1.Expression.toFunction(retval.name, args);
+            t.multiplier = retval.multiplier;
+            t = Expression_1.Expression.setPower(t, retval.getPower());
+            retval = t;
+        }
+    }
+    else {
+        let t = Expression_1.Expression.toFunction(retval.name, args);
+        t.multiplier = retval.multiplier;
+        t = Expression_1.Expression.setPower(t, retval.getPower());
+        retval = t;
+    }
+    return retval;
+}
+/**
+ * Expands the function by distributing the power and the multiplier whenever possible
+ *
+ * @param x
+ */
+function expand(x) {
+    let retval;
+    x = unwrap(x);
+    if (isExpandable(x)) {
+        if (x.isNUM() || x.isVAR()) {
+            retval = new Expression_1.Expression(x);
+        }
+        else {
+            // At the very least the multiplier must be distributed along the expression
+            retval = x.distributeMultiplier();
+            // First expand the power if it's a GRP or SUM
+            if (retval.isSum()) {
+                // First expand each term
+                retval = powerExpand(retval);
+                if (retval.isSum()) {
+                    retval = expandTerms(retval);
+                }
+            }
+            // Expand products
+            if (retval.isProduct()) {
+                retval = productExpand(retval);
+            }
+            // Expand arguments
+            if (retval.isFunction()) {
+                // Just parse it. This can probably be more efficient
+                const args = retval.getArguments().map(x => {
+                    return expand(x);
+                });
+                if (retval.name === constants_1.FACTORIAL) {
+                    retval = factorialExpand(retval);
+                }
+                else {
+                    let t = Expression_1.Expression.toFunction(retval.name, args);
+                    // Copy over the power and multiplier
+                    t.multiplier = retval.multiplier;
+                    t = Expression_1.Expression.setPower(t, retval.getPower());
+                    retval = t;
+                }
+            }
+            if (retval.isEXP()) {
+                const pow = expand(retval.getPower());
+                const expression = expand(retval.getBase());
+                const t = expression.pow(pow);
+                t.multiplier = t.getMultiplier().times(retval.getMultiplier());
+                retval = t;
+            }
+        }
+    }
+    else {
+        retval = new Expression_1.Expression(x);
+    }
+    return retval;
+}

package/output/core/functions/fresnelNumeric.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Evaluates the normalized Fresnel integrals with JavaScript-number arithmetic.
+ *
+ * Moderate arguments use adaptive Simpson integration over short segments. Large
+ * arguments use the standard asymptotic expansions, avoiding excessive work as
+ * the integrand becomes increasingly oscillatory.
+ */
+export declare function fresnelIntegral(x: number, sine: number): number;
+/** Numerical Fresnel sine integral for compiled expressions. */
+export declare function fresnelS(x: number): number;
+/** Numerical Fresnel cosine integral for compiled expressions. */
+export declare function fresnelC(x: number): number;

package/output/core/functions/fresnelNumeric.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fresnelIntegral = fresnelIntegral;
+exports.fresnelS = fresnelS;
+exports.fresnelC = fresnelC;
+/**
+ * Evaluates the normalized Fresnel integrals with JavaScript-number arithmetic.
+ *
+ * Moderate arguments use adaptive Simpson integration over short segments. Large
+ * arguments use the standard asymptotic expansions, avoiding excessive work as
+ * the integrand becomes increasingly oscillatory.
+ */
+function fresnelIntegral(x, sine) {
+    const ASYMPTOTIC_CUTOFF = 8;
+    const ASYMPTOTIC_F_COEFFICIENTS = [1, -3, 105, -10395];
+    const ASYMPTOTIC_G_COEFFICIENTS = [1, -15, 945, -135135];
+    const HALF = 0.5;
+    const INTEGRATION_TOLERANCE = 1e-13;
+    const MAX_DEPTH = 20;
+    const SEGMENTS_PER_UNIT = 2;
+    const SIMPSON_DIVISOR = 6;
+    const SIMPSON_ERROR_FACTOR = 15;
+    const SIMPSON_MIDDLE_WEIGHT = 4;
+    let retval;
+    if (Number.isNaN(x)) {
+        retval = NaN;
+    }
+    else if (!Number.isFinite(x)) {
+        retval = Math.sign(x) * HALF;
+    }
+    else if (x === 0) {
+        retval = 0;
+    }
+    else {
+        const sign = x < 0 ? -1 : 1;
+        x = Math.abs(x);
+        const phase = Math.PI * x * x * HALF;
+        const useSine = sine !== 0;
+        if (x >= ASYMPTOTIC_CUTOFF) {
+            const t = 1 / (Math.PI * Math.PI * x ** 4);
+            const [f0, f1, f2, f3] = ASYMPTOTIC_F_COEFFICIENTS;
+            const [g0, g1, g2, g3] = ASYMPTOTIC_G_COEFFICIENTS;
+            const f = (f0 + f1 * t + f2 * t ** 2 + f3 * t ** 3) / (Math.PI * x);
+            const g = (g0 + g1 * t + g2 * t ** 2 + g3 * t ** 3) / (Math.PI ** 2 * x ** 3);
+            const value = useSine
+                ? HALF - f * Math.cos(phase) - g * Math.sin(phase)
+                : HALF + f * Math.sin(phase) - g * Math.cos(phase);
+            retval = sign * value;
+        }
+        else {
+            const fn = useSine
+                ? (value) => Math.sin(Math.PI * value * value * HALF)
+                : (value) => Math.cos(Math.PI * value * value * HALF);
+            const segments = Math.max(1, Math.ceil(x * SEGMENTS_PER_UNIT));
+            let total = 0;
+            let a = 0;
+            for (let segment = 0; segment < segments; segment++) {
+                const b = (x * (segment + 1)) / segments;
+                const midpoint = (a + b) * HALF;
+                const fa = fn(a);
+                const fm = fn(midpoint);
+                const fb = fn(b);
+                const whole = ((b - a) / SIMPSON_DIVISOR) *
+                    (fa + SIMPSON_MIDDLE_WEIGHT * fm + fb);
+                const stack = [
+                    [a, b, fa, fm, fb, whole, 0],
+                ];
+                while (stack.length > 0) {
+                    const frame = stack.pop();
+                    const [left, right, fLeft, fMiddle, fRight, previous, depth] = frame;
+                    const middle = (left + right) * HALF;
+                    const leftMiddle = (left + middle) * HALF;
+                    const rightMiddle = (middle + right) * HALF;
+                    const fLeftMiddle = fn(leftMiddle);
+                    const fRightMiddle = fn(rightMiddle);
+                    const leftIntegral = ((middle - left) / SIMPSON_DIVISOR) *
+                        (fLeft + SIMPSON_MIDDLE_WEIGHT * fLeftMiddle + fMiddle);
+                    const rightIntegral = ((right - middle) / SIMPSON_DIVISOR) *
+                        (fMiddle + SIMPSON_MIDDLE_WEIGHT * fRightMiddle + fRight);
+                    const refined = leftIntegral + rightIntegral;
+                    if (depth >= MAX_DEPTH ||
+                        Math.abs(refined - previous) <=
+                            (SIMPSON_ERROR_FACTOR * INTEGRATION_TOLERANCE) / segments) {
+                        total += refined + (refined - previous) / SIMPSON_ERROR_FACTOR;
+                    }
+                    else {
+                        stack.push([
+                            middle,
+                            right,
+                            fMiddle,
+                            fRightMiddle,
+                            fRight,
+                            rightIntegral,
+                            depth + 1,
+                        ]);
+                        stack.push([
+                            left,
+                            middle,
+                            fLeft,
+                            fLeftMiddle,
+                            fMiddle,
+                            leftIntegral,
+                            depth + 1,
+                        ]);
+                    }
+                }
+                a = b;
+            }
+            retval = sign * total;
+        }
+    }
+    return retval;
+}
+/** Numerical Fresnel sine integral for compiled expressions. */
+function fresnelS(x) {
+    const retval = fresnelIntegral(x, 1);
+    return retval;
+}
+/** Numerical Fresnel cosine integral for compiled expressions. */
+function fresnelC(x) {
+    const retval = fresnelIntegral(x, 0);
+    return retval;
+}

package/output/core/functions/numeric.d.ts

@@ -0,0 +1,140 @@
+declare const EULER_GAMMA = 0.5772156649015329;
+export { EULER_GAMMA };
+/**
+ * Computes factorial values with JavaScript-number arithmetic for compiled expressions.
+ *
+ * Non-integers use the gamma extension. Negative or unsafe integers return `NaN`, and
+ * sufficiently large positive integers naturally overflow to `Infinity`.
+ */
+export declare function factorial(x: number): number;
+/**
+ * The gammaLN function which is used to compute the gamma function
+ * Ported from: https://www.mrob.com/pub/ries/lanczos-gamma.html
+ *
+ * @param x
+ */
+export declare function gammaLN(z: number): number;
+/**
+ * The gamma function
+ *
+ * @param z
+ * @returns
+ */
+export declare function gamma(z: number): number;
+/**
+ * The complementary error function
+ * https://en.wikipedia.org/wiki/Error_function
+ *
+ * @param x
+ */
+export declare function erfc(x: number): number;
+/**
+ * The numeric error function
+ *
+ * @param x
+ * @returns
+ */
+export declare function erf(x: number): number;
+/**
+ * Computes the Euclidean GCD of JavaScript safe integers for numerical compilation.
+ *
+ * This is the small native-number helper used by `buildFunction`; it is separate from
+ * Nerdamer's symbolic polynomial GCD implementation. Non-safe-integer inputs return `NaN`.
+ */
+export declare function GCD(...args: number[]): number;
+/**
+ * A utility function to check if a number is an integer
+ *
+ * @param x
+ * @returns
+ */
+export declare function isInt(x: number): boolean;
+/**
+ * Computes the double factorial using JavaScript-number arithmetic.
+ *
+ * Non-negative integer inputs use the finite product directly. Non-integers follow
+ * the same gamma-based extension used by the symbolic implementation. Negative or
+ * unsafe integer inputs return `NaN`.
+ */
+export declare function doubleFactorial(x: number): number;
+/**
+ * Computes an LCM while the exact integer result remains representable as a safe number.
+ * Inputs or results outside that range return `NaN`.
+ */
+export declare function LCM(...args: number[]): number;
+/** Computes the modular multiplicative inverse for integer JavaScript numbers. */
+export declare function modInv(a: number, p: number): number;
+/** Returns `1` for a prime safe integer and `0` otherwise. */
+export declare function isPrime(x: number): 0 | 1;
+/** Numeric half-maximum convention for the Heaviside step function. */
+export declare function heaviside(x: number): number;
+/**
+ * Rounds a number to n digits
+ * @param x The number to be rounded
+ * @param s The number of digits to round to
+ * @returns
+ */
+export declare function round(x: number, n?: number): number;
+/**
+ * Multiplies an array of numbers
+ *
+ * @param args
+ * @returns
+ */
+export declare function product(...args: number[]): number;
+/**
+ * Gets the product given a number range start and finish
+ *
+ * @param start The start of the range
+ * @param end The end of the range
+ * @param step The increment step
+ */
+export declare function productInRange(start: number, end: number, step?: number): number;
+/**
+ * Gets the average of a set of numbers
+ *
+ * @param args
+ * @returns
+ */
+export declare function avg(...args: number[]): number;
+/**
+ * Sums an array of numbers
+ *
+ * @param args
+ * @returns
+ */
+export declare function sum(...args: number[]): number;
+/**
+ * Generates a random integer between a min and max
+ *
+ * @param min
+ * @param max
+ * @returns
+ */
+export declare function getRandomInt(min: number, max: number): number;
+/**
+ * Returns the modulus of a number. Allows for negative numbers
+ *
+ * @param n
+ * @param m
+ * @returns
+ */
+export declare function mod(n: number, m: number): number;
+/**
+ * Return a function which returns a numeric approximation of the derivative of the provided function
+ * @example
+ * const d = diff(Math.cos);
+ * d(Math.PI) // 0
+ *
+ * @param f The function to be differentiated
+ * @param h The delta to be used
+ * @returns
+ */
+export declare function diff(f: (x: number) => number, h?: number): (x: number) => number;
+export declare function sinc(x: number): number;
+export declare function Si(x: number): number;
+export declare function Shi(x: number): number;
+export declare function Ci(x: number): number;
+export declare function Chi(x: number): number;
+export declare function Ei(x: number): number;
+export declare function Li(x: number): number;