math-expression-compiler 0.0.0-stage → 4.3.3

package/dist/index.d.ts

@@ -0,0 +1,405 @@
+import { Result } from "neverthrow";
+export type MathExpressionResult = null | number;
+export type MathExpressionEvaluator = (values: readonly number[], locals: MathExpressionResult[]) => MathExpressionResult;
+export interface MathExpressionCompiled {
+  evaluate: MathExpressionEvaluator;
+  isConstant: boolean;
+}
+export declare enum MathExpressionLogicalOperator {
+  And = "and",
+  Nullish = "nullish",
+  Or = "or"
+}
+export declare enum MathExpressionNodeType {
+  Assignment = "assignment",
+  Binary = "binary",
+  Call = "call",
+  Comparison = "comparison",
+  Conditional = "conditional",
+  Group = "group",
+  List = "list",
+  Logical = "logical",
+  Name = "name",
+  Number = "number",
+  Percentage = "percentage",
+  Unary = "unary"
+}
+export type MathExpressionNode = {
+  arguments: MathExpressionNode[];
+  name: string;
+  type: MathExpressionNodeType.Call;
+} | {
+  condition: MathExpressionNode;
+  type: MathExpressionNodeType.Conditional;
+  whenFalse: MathExpressionNode;
+  whenTrue: MathExpressionNode;
+} | {
+  elements: MathExpressionNode[];
+  type: MathExpressionNodeType.List;
+} | {
+  left: MathExpressionNode;
+  name: string;
+  right: MathExpressionNode;
+  type: MathExpressionNodeType.Binary;
+} | {
+  left: MathExpressionNode;
+  operator: MathExpressionLogicalOperator;
+  right: MathExpressionNode;
+  type: MathExpressionNodeType.Logical;
+} | {
+  name: string;
+  operand: MathExpressionNode;
+  type: MathExpressionNodeType.Unary;
+} | {
+  name: string;
+  type: MathExpressionNodeType.Assignment;
+  value: MathExpressionNode;
+} | {
+  name: string;
+  type: MathExpressionNodeType.Name;
+} | {
+  names: string[];
+  operands: MathExpressionNode[];
+  type: MathExpressionNodeType.Comparison;
+} | {
+  operand: MathExpressionNode;
+  type: MathExpressionNodeType.Group;
+} | {
+  operand: MathExpressionNode;
+  type: MathExpressionNodeType.Percentage;
+} | {
+  type: MathExpressionNodeType.Number;
+  value: number;
+};
+export interface MathExpressionCompileContext {
+  assignedSlots: ReadonlyMap<string, number>;
+  compile: (node: MathExpressionNode) => MathExpressionCompiled;
+  variableIndices: ReadonlyMap<string, number>;
+}
+export type MathExpressionValue = number | number[];
+export interface MathExpressionCompiledArgument {
+  evaluate: (values: readonly number[], locals: MathExpressionResult[]) => MathExpressionValue | null;
+  isConstant: boolean;
+}
+export interface MathExpressionOuterBinding {
+  constant?: number;
+  variableIndex?: number;
+}
+export type MathExpressionBinaryCompute = (left: number, right: number) => null | number;
+export declare enum MathExpressionFunctionName {
+  CTranspose = "ctranspose",
+  Factorial = "factorial",
+  UnaryMinus = "unaryMinus",
+  UnaryPlus = "unaryPlus"
+}
+export type MathExpressionNumberCompute = (values: readonly number[]) => null | number;
+export declare enum MathExpressionParameterType {
+  Any = "any",
+  List = "list",
+  Number = "number"
+}
+export type MathExpressionUnaryCompute = (value: number) => null | number;
+export interface MathExpressionSignature {
+  compute: (values: readonly MathExpressionValue[]) => null | number;
+  computeBinary?: MathExpressionBinaryCompute;
+  computeUnary?: MathExpressionUnaryCompute;
+  maxArity: number;
+  minArity: number;
+  parameters: MathExpressionParameterType[];
+}
+export type MathExpressionScalarCompute = Pick<MathExpressionSignature, "computeBinary" | "computeUnary">;
+export interface MathExpressionBinaryFunctionOperator {
+  name: string;
+  power: number;
+  type: MathExpressionNodeType.Binary;
+}
+export type MathExpressionBinaryOperator = MathExpressionBinaryFunctionOperator | {
+  name: string;
+  power: number;
+  type: MathExpressionNodeType.Comparison;
+} | {
+  operator: MathExpressionLogicalOperator;
+  power: number;
+  type: MathExpressionNodeType.Logical;
+};
+export declare enum MathExpressionGrammarRule {
+  Assignment = "Assignment",
+  Binary = "Binary",
+  Conditional = "Conditional",
+  DivisionBeforeProduct = "DivisionBeforeProduct",
+  ImplicitProduct = "ImplicitProduct",
+  LeftHand = "LeftHand",
+  Nullish = "Nullish",
+  Percentage = "Percentage",
+  Power = "Power",
+  Symbol = "Symbol",
+  Unary = "Unary"
+}
+export declare enum MathExpressionTokenType {
+  Delimiter = "delimiter",
+  Null = "null",
+  Number = "number",
+  Symbol = "symbol",
+  Unknown = "unknown"
+}
+export declare class MathExpressionError extends Error {
+  constructor(message: string);
+}
+export interface MathExpressionParserState {
+  depth: number;
+  error: MathExpressionError | null;
+  index: number;
+  nestingLevel: number;
+  source: string;
+  token: string;
+  tokenType: MathExpressionTokenType;
+}
+export type MathExpressionParse = (state: MathExpressionParserState, rule: MathExpressionGrammarRule) => MathExpressionNode;
+export type MathExpressionRuleParser = (state: MathExpressionParserState, parse: MathExpressionParse) => MathExpressionNode;
+export declare const MathExpressionBitwiseAbsorptionMap: Readonly<Record<string, {
+  absorbs: number;
+  result: number;
+}>>;
+export declare const MathExpressionNodeCompileMap: { [T in MathExpressionNodeType]: (node: Extract<MathExpressionNode, {
+  type: T;
+}>, context: MathExpressionCompileContext) => MathExpressionCompiled; };
+export declare const checkIsPercentageExpression: (node: MathExpressionNode) => boolean;
+export declare const collectMathExpressionAssignedNames: (node: MathExpressionNode, names: Set<string>) => void;
+export declare const compileArgument: (node: MathExpressionNode, context: MathExpressionCompileContext) => MathExpressionCompiledArgument;
+export declare const compileList: (elements: MathExpressionNode[], context: MathExpressionCompileContext) => MathExpressionCompiledArgument;
+export declare const compileMathExpression: (node: MathExpressionNode, variableNames: readonly string[]) => ((values: readonly number[]) => number);
+export declare const compileMathExpressionNode: (node: MathExpressionNode, context: MathExpressionCompileContext) => MathExpressionCompiled;
+export declare const NO_VALUES: readonly number[];
+export declare const NO_LOCALS: MathExpressionResult[];
+export declare const ADDITIVE_NAMES: readonly string[];
+export declare const getMathExpressionConstant: (name: string) => number | undefined;
+export declare const getMathExpressionOuterValue: (outer: MathExpressionOuterBinding, values: readonly number[]) => MathExpressionResult;
+export declare const getMathExpressionScalarCompute: <Key extends keyof MathExpressionScalarCompute>(name: string, key: Key) => NonNullable<MathExpressionScalarCompute[Key]>;
+export declare const compileAssignment: (node: Extract<MathExpressionNode, {
+  type: MathExpressionNodeType.Assignment;
+}>, context: MathExpressionCompileContext) => MathExpressionCompiled;
+export declare const compileBinary: (node: Extract<MathExpressionNode, {
+  type: MathExpressionNodeType.Binary;
+}>, context: MathExpressionCompileContext) => MathExpressionCompiled;
+export declare const compileCall: (node: Extract<MathExpressionNode, {
+  type: MathExpressionNodeType.Call;
+}>, context: MathExpressionCompileContext) => MathExpressionCompiled;
+export declare const compileComparison: (node: Extract<MathExpressionNode, {
+  type: MathExpressionNodeType.Comparison;
+}>, context: MathExpressionCompileContext) => MathExpressionCompiled;
+export declare const compileConditional: (node: Extract<MathExpressionNode, {
+  type: MathExpressionNodeType.Conditional;
+}>, context: MathExpressionCompileContext) => MathExpressionCompiled;
+export declare const compileGroup: (node: Extract<MathExpressionNode, {
+  type: MathExpressionNodeType.Group;
+}>, context: MathExpressionCompileContext) => MathExpressionCompiled;
+export declare const compileListNode: () => MathExpressionCompiled;
+export declare const compileLogical: (node: Extract<MathExpressionNode, {
+  type: MathExpressionNodeType.Logical;
+}>, context: MathExpressionCompileContext) => MathExpressionCompiled;
+export declare const compileName: (node: Extract<MathExpressionNode, {
+  type: MathExpressionNodeType.Name;
+}>, context: MathExpressionCompileContext) => MathExpressionCompiled;
+export declare const compileNumber: (node: Extract<MathExpressionNode, {
+  type: MathExpressionNodeType.Number;
+}>) => MathExpressionCompiled;
+export declare const compilePercentage: (node: Extract<MathExpressionNode, {
+  type: MathExpressionNodeType.Percentage;
+}>, context: MathExpressionCompileContext) => MathExpressionCompiled;
+export declare const compileUnary: (node: Extract<MathExpressionNode, {
+  type: MathExpressionNodeType.Unary;
+}>, context: MathExpressionCompileContext) => MathExpressionCompiled;
+export declare const MathExpressionFunctionMap: Record<string, MathExpressionSignature[]>;
+export declare const checkIsLarger: (left: number, right: number) => boolean;
+export declare const checkIsMillerRabinPassing: (candidate: bigint, base: bigint, oddPart: bigint, twos: number) => boolean;
+export declare const checkIsNearlyEqual: (left: number, right: number) => boolean;
+export declare const checkIsPrime: (value: number) => boolean;
+export declare const checkIsSmaller: (left: number, right: number) => boolean;
+export declare const compareNumbers: (left: number, right: number) => number;
+export declare const computeBellNumber: (index: number) => null | number;
+export declare const computeBernoulliNumber: (index: number) => number;
+export declare const computeBitwiseAnd: (left: number, right: number) => number;
+export declare const computeBitwiseOr: (left: number, right: number) => number;
+export declare const computeCatalan: (index: number) => null | number;
+export declare const computeCombinations: (available: number, chosen: number) => number;
+export declare const computeComparison: (left: number, right: number) => number;
+export declare const computeCompositions: (total: number, parts: number) => null | number;
+export declare const computeCorrelation: (left: readonly number[], right: readonly number[]) => null | number;
+export declare const computeDeterminant: (values: readonly number[]) => null | number;
+export declare const computeDistance: (point: number[], other: number[]) => null | number;
+export declare const computeDotProduct: (left: readonly number[], right: readonly number[]) => null | number;
+export declare const computeErf: (value: number) => number;
+export declare const computeErfInverse: (value: number) => number;
+export declare const computeExtreme: (values: readonly number[], initial: number, checkIsPreferred: (value: number, extreme: number) => boolean) => number;
+export declare const computeFactorial: (value: number) => null | number;
+export declare const computeGamma: (value: number) => number;
+export declare const computeGreatestCommonDivisor: (left: number, right: number) => number;
+export declare const computeHypotenuse: (values: readonly number[]) => number;
+export declare const computeInitialGuess: (value: number) => number;
+export declare const computeIntegerGreatestCommonDivisor: (values: readonly number[]) => null | number;
+export declare const computeInverseCoth: (value: number) => number;
+export declare const computeKullbackLeibler: (distribution: readonly number[], reference: readonly number[]) => null | number;
+export declare const computeLeastCommonMultiple: (left: number, right: number) => null | number;
+export declare const computeListComparison: (left: number[], right: number[]) => number;
+export declare const computeLogGamma: (value: number) => number;
+export declare const computeLogGammaOfPositive: (value: number) => {
+  logGamma: number;
+  product: number;
+};
+export declare const computeLogarithm: (value: number, base?: number) => number;
+export declare const computeMean: (values: readonly number[]) => number;
+export declare const computeMedian: (values: readonly number[]) => number;
+export declare const computeMedianAbsoluteDeviation: (values: readonly number[]) => number;
+export declare const computeModularInverse: (value: number, modulus: number) => null | number;
+export declare const computeModularPower: (base: bigint, exponent: bigint, modulus: bigint) => bigint;
+export declare const computeModulo: (dividend: number, divisor: number) => number;
+export declare const computeMultinomial: (parts: readonly number[]) => null | number;
+export declare const computeNorm: (values: readonly number[]) => null | number;
+export declare const computeNthRoot: (value: number, root: number) => null | number;
+export declare const computePartitionSelect: (values: number[], index: number) => null | number;
+export declare const computePermutations: (available: number, chosen: number) => null | number;
+export declare const computePointToLine2D: (point: number[], line: number[]) => number;
+export declare const computePointToLine3D: (point: number[], line: number[]) => number;
+export declare const computePolynomial: (leading: number, coefficients: readonly number[], variable: number) => number;
+export declare const computeProduct: (values: readonly MathExpressionValue[]) => null | number;
+export declare const computeProductOfRange: (first: number, last: number) => number;
+export declare const computeQuantile: (values: number[], probability: number, isSorted: boolean) => null | number;
+export declare const computeStirlingColumn: (count: number, parts: number) => number;
+export declare const computeStirlingDiagonal: (count: number, index: number) => number;
+export declare const computeStirlingLogGamma: (value: number) => number;
+export declare const computeStirlingSecondKind: (count: number, parts: number) => null | number;
+export declare const computeSum: (values: readonly number[]) => number;
+export declare const computeSummedZeta: (value: number) => number;
+export declare const computeTruthyCount: (values: readonly number[]) => number;
+export declare const computeVariance: (values: readonly number[]) => number;
+export declare const computeVectorNorm: (values: readonly number[], power: number) => null | number;
+export declare const computeZeta: (value: number) => number;
+export declare const MATH_EXPRESSION_RELATIVE_TOLERANCE = 1e-12;
+export declare const MATH_EXPRESSION_ABSOLUTE_TOLERANCE = 1e-15;
+export declare const SQRT_PI: number;
+export declare const BERNOULLI_CLOSED_FORM_INDEX = 54;
+export declare const MAXIMUM_DIGITS = 15;
+export declare const MAXIMUM_STIRLING_WORK = 4e6;
+export declare const MILLER_RABIN_BASES: readonly bigint[];
+export declare const REFINEMENT_STEPS = 4;
+export declare const LOW_TAIL_COEFFICIENTS: readonly number[];
+export declare const HIGH_TAIL_COEFFICIENTS: readonly number[];
+export declare const OVERFLOW_ARGUMENT = 171.35;
+export declare const LAST_FACTORIAL_ARGUMENT = 171;
+export declare const STIRLING_THRESHOLD = 15;
+export declare const STIRLING_TERMS: readonly number[];
+export declare const EULER_MACLAURIN_COEFFICIENTS: readonly number[];
+export declare const SUMMATION_LIMIT = 10;
+export declare const multiplyPair: (left: MathExpressionValue, right: MathExpressionValue) => MathExpressionValue | null;
+export declare const roundToDigits: (rounder: (value: number) => number, value: number, digits: number) => null | number;
+export declare const scaleList: (list: number[], scalar: number) => number[];
+export declare const shiftDecimalPlaces: (value: number, places: number) => number;
+export declare const createBinarySignatures: (compute: MathExpressionBinaryCompute) => MathExpressionSignature[];
+export declare const createBitwiseFold: (absorbing: number, compute: (left: number, right: number) => number) => MathExpressionNumberCompute;
+export declare const createBitwisePair: (absorbing: number, compute: (left: number, right: number) => number) => MathExpressionBinaryCompute;
+export declare const createDigitSignatures: (rounder: (value: number) => number) => MathExpressionSignature[];
+export declare const createExtremeSignatures: (checkIsPreferred: (value: number, extreme: number) => boolean) => MathExpressionSignature[];
+export declare const createIdentitySignatures: () => MathExpressionSignature[];
+export declare const createIntegerBinarySignatures: (compute: (left: number, right: number) => null | number) => MathExpressionSignature[];
+export declare const createIntegerUnarySignatures: (compute: (value: number) => null | number) => MathExpressionSignature[];
+export declare const createListFirstCompute: (compute: (list: number[], numbers: number[]) => null | number) => MathExpressionSignature["compute"];
+export declare const createListPairCompute: (compute: (left: number[], right: number[]) => null | number) => MathExpressionSignature["compute"];
+export declare const createListPairSignature: (compute: (left: number[], right: number[]) => null | number) => MathExpressionSignature;
+export declare const createListSignature: (compute: MathExpressionNumberCompute) => MathExpressionSignature;
+export declare const createNonEmptyCompute: (compute: (values: readonly number[]) => number) => MathExpressionNumberCompute;
+export declare const createNumberSignature: (minArity: number, maxArity: number, compute: MathExpressionNumberCompute, scalarCompute?: MathExpressionScalarCompute) => MathExpressionSignature;
+export declare const createNumericCompute: (compute: MathExpressionNumberCompute) => MathExpressionSignature["compute"];
+export declare const createOrderedListSignatures: (compute: (left: number[], right: number[]) => null | number) => MathExpressionSignature[];
+export declare const createRangedSignatures: (minArity: number, maxArity: number, compute: MathExpressionNumberCompute, scalarCompute?: MathExpressionScalarCompute) => MathExpressionSignature[];
+export declare const createSignature: (parameters: MathExpressionParameterType[], minArity: number, maxArity: number, compute: MathExpressionSignature["compute"], scalarCompute?: MathExpressionScalarCompute) => MathExpressionSignature;
+export declare const createSingletonListSignature: (compute: MathExpressionUnaryCompute) => MathExpressionSignature;
+export declare const createSpreadSignatures: (minArity: number, compute: MathExpressionNumberCompute) => MathExpressionSignature[];
+export declare const createUnarySignatures: (compute: MathExpressionUnaryCompute) => MathExpressionSignature[];
+export declare const createVariadicSignatures: (minArity: number, compute: MathExpressionNumberCompute, computeBinary?: MathExpressionBinaryCompute) => MathExpressionSignature[];
+export declare const getMathExpressionNames: (node: MathExpressionNode) => string[];
+export declare const walkNode: (node: MathExpressionNode, bound: Set<string>, free: Set<string>) => void;
+export declare const MathExpressionBinaryOperatorMap: {
+  readonly "*": MathExpressionBinaryFunctionOperator;
+  readonly "/": MathExpressionBinaryFunctionOperator;
+  readonly [token: string]: MathExpressionBinaryOperator;
+};
+export declare const MathExpressionOperatorMap: {
+  [MathExpressionGrammarRule.Nullish]: Readonly<Record<string, MathExpressionLogicalOperator>>;
+  [MathExpressionGrammarRule.Power]: Readonly<Record<string, string>>;
+  [MathExpressionGrammarRule.Unary]: Readonly<Record<string, string>>;
+};
+export declare const MathExpressionRuleParserMap: Record<MathExpressionGrammarRule, MathExpressionRuleParser>;
+export declare const checkCanMathExpressionNest: (state: MathExpressionParserState) => boolean;
+export declare const checkIsNameToken: (state: MathExpressionParserState) => boolean;
+export declare const checkIsOperatorOperand: (node: MathExpressionNode) => boolean;
+export declare const checkIsSignedNumber: (node: MathExpressionNode) => boolean;
+export declare const checkIsToken: (state: MathExpressionParserState, token: string) => boolean;
+export declare const checkIsUnaryStart: (state: MathExpressionParserState) => boolean;
+export declare const computeNumberLiteral: (token: string) => null | number;
+export declare const MAX_MATH_EXPRESSION_DEPTH = 64;
+export declare const PLACEHOLDER: MathExpressionNode;
+export declare const createBinaryNode: (left: MathExpressionNode, name: string, right: MathExpressionNode) => MathExpressionNode;
+export declare const createBinaryOperation: (left: MathExpressionNode, operator: MathExpressionBinaryOperator, right: MathExpressionNode) => MathExpressionNode;
+export declare const createLogicalNode: (left: MathExpressionNode, operator: MathExpressionLogicalOperator, right: MathExpressionNode) => MathExpressionNode;
+export declare const failMathExpression: (state: MathExpressionParserState, message: string) => void;
+export declare const failMathExpressionAt: (state: MathExpressionParserState, message: string, column: number) => void;
+export declare const getArgumentCountText: (count: number) => string;
+export declare const getMathExpressionArityMessage: (name: string, minArity: number, maxArity: number) => string;
+export declare const getMathExpressionColumn: (state: MathExpressionParserState) => number;
+export declare const getMathExpressionSignatureError: (name: string, signatures: readonly MathExpressionSignature[], parameterTypes: MathExpressionParameterType[]) => string;
+export declare const getMathExpressionToken: (state: MathExpressionParserState) => void;
+export declare const parseArgument: (state: MathExpressionParserState, parse: MathExpressionParse) => MathExpressionNode;
+export declare const parseBinaryOperators: (state: MathExpressionParserState, parse: MathExpressionParse, minimumPower: number) => MathExpressionNode;
+export declare const parseCall: (state: MathExpressionParserState, name: string, column: number, parse: MathExpressionParse) => MathExpressionNode;
+export declare const parseList: (state: MathExpressionParserState, parse: MathExpressionParse) => MathExpressionNode;
+export declare const parseMathExpression: (formula: string) => Result<MathExpressionNode, MathExpressionError>;
+export declare const parseMathExpressionRule: (state: MathExpressionParserState, rule: MathExpressionGrammarRule) => MathExpressionNode;
+export declare const parseSequence: (state: MathExpressionParserState, closing: string, parseItem: (state: MathExpressionParserState) => MathExpressionNode) => MathExpressionNode[];
+export declare const parseAssignment: MathExpressionRuleParser;
+export declare const parseBinary: MathExpressionRuleParser;
+export declare const parseConditional: MathExpressionRuleParser;
+export declare const parseDivisionBeforeProduct: MathExpressionRuleParser;
+export declare const parseImplicitProduct: MathExpressionRuleParser;
+export declare const parseLeftHand: MathExpressionRuleParser;
+export declare const parseNullish: MathExpressionRuleParser;
+export declare const parsePercentage: MathExpressionRuleParser;
+export declare const parsePower: MathExpressionRuleParser;
+export declare const parseSymbol: MathExpressionRuleParser;
+export declare const parseUnary: MathExpressionRuleParser;
+export declare const MathExpressionRadixMap: Readonly<Record<string, {
+  digit: RegExp;
+  radix: number;
+}>>;
+export declare const checkIsDecimalMark: (character: string, nextCharacter: string) => boolean;
+export declare const checkIsDigitCharacter: (character: string) => boolean;
+export declare const checkIsWordCharacter: (character: string) => boolean;
+export declare const checkIsWordStartCharacter: (character: string) => boolean;
+export declare const DELIMITERS_OF_THREE: ReadonlySet<string>;
+export declare const DELIMITERS_OF_TWO: ReadonlySet<string>;
+export declare const DELIMITERS_OF_ONE: ReadonlySet<string>;
+export declare const FIRST_CHARACTERS_OF_THREE: ReadonlySet<string>;
+export declare const FIRST_CHARACTERS_OF_TWO: ReadonlySet<string>;
+export declare const NAMED_DELIMITERS: ReadonlySet<string>;
+export declare const DECIMAL_MARK_OPERATOR_FOLLOWERS: ReadonlySet<string>;
+export declare const WORD_START_REGEX: RegExp;
+export declare const WORD_CHARACTER_REGEX: RegExp;
+export declare const failExponent: (state: MathExpressionParserState, text: string) => void;
+export declare const getMathExpressionCharacter: (state: MathExpressionParserState, offset: number) => string;
+export declare const readMathExpressionDelimiter: (state: MathExpressionParserState) => number;
+export declare const readMathExpressionNumber: (state: MathExpressionParserState) => void;
+export declare const readMathExpressionWord: (state: MathExpressionParserState) => void;
+export declare const readRadixNumber: (state: MathExpressionParserState, prefix: string, baseDigits: RegExp) => void;
+export declare const skipMathExpressionSpaces: (state: MathExpressionParserState) => void;
+export declare const takeExponent: (state: MathExpressionParserState, text: string) => string;
+export declare const takeMathExpressionMatching: (state: MathExpressionParserState, checkCharacter: (character: string) => boolean) => string;
+export declare const MathExpressionConstantMap: Record<string, number>;
+export declare const checkIsMatching: (signature: MathExpressionSignature, parameterTypes: MathExpressionParameterType[]) => boolean;
+export declare const checkIsMatchingKind: (parameterType: MathExpressionParameterType | undefined, argumentType: MathExpressionParameterType) => boolean;
+export declare const checkIsTruthy: (value: number) => boolean;
+export declare const getMathExpressionChildren: (node: MathExpressionNode) => MathExpressionNode[];
+export declare const getMathExpressionParameterType: (node: MathExpressionNode) => MathExpressionParameterType;
+export declare const getMathExpressionSignatures: (name: string) => MathExpressionSignature[] | undefined;
+export declare const getOwnValue: <T>(record: Readonly<Record<string, T>>, key: string) => T | undefined;
+export declare const getParameterType: (signature: MathExpressionSignature, index: number) => MathExpressionParameterType | undefined;
+export declare const matchMathExpressionSignature: (signatures: readonly MathExpressionSignature[], parameterTypes: MathExpressionParameterType[]) => MathExpressionSignature | undefined;
+export declare const toNumber: (flag: boolean) => number;