math-expression-compiler 0.0.0-stage → 4.3.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +201 -0
- package/README.md +65 -2
- package/dist/index.d.ts +813 -0
- package/dist/index.js +2246 -0
- package/package.json +50 -4
package/dist/index.d.ts
ADDED
|
@@ -0,0 +1,813 @@
|
|
|
1
|
+
import { Result } from "neverthrow";
|
|
2
|
+
//#region src/models/compiler/MathExpressionResult.d.ts
|
|
3
|
+
export type MathExpressionResult = null | number;
|
|
4
|
+
//#endregion
|
|
5
|
+
//#region src/models/compiler/MathExpressionEvaluator.d.ts
|
|
6
|
+
export type MathExpressionEvaluator = (values: readonly number[], locals: MathExpressionResult[]) => MathExpressionResult;
|
|
7
|
+
//#endregion
|
|
8
|
+
//#region src/models/compiler/MathExpressionCompiled.d.ts
|
|
9
|
+
export interface MathExpressionCompiled {
|
|
10
|
+
evaluate: MathExpressionEvaluator;
|
|
11
|
+
isConstant: boolean;
|
|
12
|
+
}
|
|
13
|
+
//#endregion
|
|
14
|
+
//#region src/models/shared/MathExpressionLogicalOperator.d.ts
|
|
15
|
+
export declare enum MathExpressionLogicalOperator {
|
|
16
|
+
And = "and",
|
|
17
|
+
Nullish = "nullish",
|
|
18
|
+
Or = "or"
|
|
19
|
+
}
|
|
20
|
+
//#endregion
|
|
21
|
+
//#region src/models/shared/MathExpressionNodeType.d.ts
|
|
22
|
+
export declare enum MathExpressionNodeType {
|
|
23
|
+
Assignment = "assignment",
|
|
24
|
+
Binary = "binary",
|
|
25
|
+
Call = "call",
|
|
26
|
+
Comparison = "comparison",
|
|
27
|
+
Conditional = "conditional",
|
|
28
|
+
Group = "group",
|
|
29
|
+
List = "list",
|
|
30
|
+
Logical = "logical",
|
|
31
|
+
Name = "name",
|
|
32
|
+
Number = "number",
|
|
33
|
+
Percentage = "percentage",
|
|
34
|
+
Unary = "unary"
|
|
35
|
+
}
|
|
36
|
+
//#endregion
|
|
37
|
+
//#region src/models/shared/MathExpressionNode.d.ts
|
|
38
|
+
export type MathExpressionNode = {
|
|
39
|
+
arguments: MathExpressionNode[];
|
|
40
|
+
name: string;
|
|
41
|
+
type: MathExpressionNodeType.Call;
|
|
42
|
+
} | {
|
|
43
|
+
condition: MathExpressionNode;
|
|
44
|
+
type: MathExpressionNodeType.Conditional;
|
|
45
|
+
whenFalse: MathExpressionNode;
|
|
46
|
+
whenTrue: MathExpressionNode;
|
|
47
|
+
} | {
|
|
48
|
+
elements: MathExpressionNode[];
|
|
49
|
+
type: MathExpressionNodeType.List;
|
|
50
|
+
} | {
|
|
51
|
+
left: MathExpressionNode;
|
|
52
|
+
name: string;
|
|
53
|
+
right: MathExpressionNode;
|
|
54
|
+
type: MathExpressionNodeType.Binary;
|
|
55
|
+
} | {
|
|
56
|
+
left: MathExpressionNode;
|
|
57
|
+
operator: MathExpressionLogicalOperator;
|
|
58
|
+
right: MathExpressionNode;
|
|
59
|
+
type: MathExpressionNodeType.Logical;
|
|
60
|
+
} | {
|
|
61
|
+
name: string;
|
|
62
|
+
operand: MathExpressionNode;
|
|
63
|
+
type: MathExpressionNodeType.Unary;
|
|
64
|
+
} | {
|
|
65
|
+
name: string;
|
|
66
|
+
type: MathExpressionNodeType.Assignment;
|
|
67
|
+
value: MathExpressionNode;
|
|
68
|
+
} | {
|
|
69
|
+
name: string;
|
|
70
|
+
type: MathExpressionNodeType.Name;
|
|
71
|
+
} | {
|
|
72
|
+
names: string[];
|
|
73
|
+
operands: MathExpressionNode[];
|
|
74
|
+
type: MathExpressionNodeType.Comparison;
|
|
75
|
+
} | {
|
|
76
|
+
operand: MathExpressionNode;
|
|
77
|
+
type: MathExpressionNodeType.Group;
|
|
78
|
+
} | {
|
|
79
|
+
operand: MathExpressionNode;
|
|
80
|
+
type: MathExpressionNodeType.Percentage;
|
|
81
|
+
} | {
|
|
82
|
+
type: MathExpressionNodeType.Number;
|
|
83
|
+
value: number;
|
|
84
|
+
};
|
|
85
|
+
//#endregion
|
|
86
|
+
//#region src/models/compiler/MathExpressionCompileContext.d.ts
|
|
87
|
+
export interface MathExpressionCompileContext {
|
|
88
|
+
assignedSlots: ReadonlyMap<string, number>;
|
|
89
|
+
compile: (node: MathExpressionNode) => MathExpressionCompiled;
|
|
90
|
+
variableIndices: ReadonlyMap<string, number>;
|
|
91
|
+
}
|
|
92
|
+
//#endregion
|
|
93
|
+
//#region src/models/function/MathExpressionValue.d.ts
|
|
94
|
+
export type MathExpressionValue = number | number[];
|
|
95
|
+
//#endregion
|
|
96
|
+
//#region src/models/compiler/MathExpressionCompiledArgument.d.ts
|
|
97
|
+
export interface MathExpressionCompiledArgument {
|
|
98
|
+
evaluate: (values: readonly number[], locals: MathExpressionResult[]) => MathExpressionValue | null;
|
|
99
|
+
isConstant: boolean;
|
|
100
|
+
}
|
|
101
|
+
//#endregion
|
|
102
|
+
//#region src/models/compiler/MathExpressionOuterBinding.d.ts
|
|
103
|
+
export interface MathExpressionOuterBinding {
|
|
104
|
+
constant?: number;
|
|
105
|
+
variableIndex?: number;
|
|
106
|
+
}
|
|
107
|
+
//#endregion
|
|
108
|
+
//#region src/models/function/MathExpressionBinaryCompute.d.ts
|
|
109
|
+
export type MathExpressionBinaryCompute = (left: number, right: number) => null | number;
|
|
110
|
+
//#endregion
|
|
111
|
+
//#region src/models/function/MathExpressionFunctionName.d.ts
|
|
112
|
+
export declare enum MathExpressionFunctionName {
|
|
113
|
+
CTranspose = "ctranspose",
|
|
114
|
+
Factorial = "factorial",
|
|
115
|
+
UnaryMinus = "unaryMinus",
|
|
116
|
+
UnaryPlus = "unaryPlus"
|
|
117
|
+
}
|
|
118
|
+
//#endregion
|
|
119
|
+
//#region src/models/function/MathExpressionNumberCompute.d.ts
|
|
120
|
+
export type MathExpressionNumberCompute = (values: readonly number[]) => null | number;
|
|
121
|
+
//#endregion
|
|
122
|
+
//#region src/models/function/MathExpressionParameterType.d.ts
|
|
123
|
+
export declare enum MathExpressionParameterType {
|
|
124
|
+
Any = "any",
|
|
125
|
+
List = "list",
|
|
126
|
+
Number = "number"
|
|
127
|
+
}
|
|
128
|
+
//#endregion
|
|
129
|
+
//#region src/models/function/MathExpressionUnaryCompute.d.ts
|
|
130
|
+
export type MathExpressionUnaryCompute = (value: number) => null | number;
|
|
131
|
+
//#endregion
|
|
132
|
+
//#region src/models/function/MathExpressionSignature.d.ts
|
|
133
|
+
export interface MathExpressionSignature {
|
|
134
|
+
compute: (values: readonly MathExpressionValue[]) => null | number;
|
|
135
|
+
computeBinary?: MathExpressionBinaryCompute;
|
|
136
|
+
computeUnary?: MathExpressionUnaryCompute;
|
|
137
|
+
maxArity: number;
|
|
138
|
+
minArity: number;
|
|
139
|
+
parameters: MathExpressionParameterType[];
|
|
140
|
+
}
|
|
141
|
+
//#endregion
|
|
142
|
+
//#region src/models/function/MathExpressionScalarCompute.d.ts
|
|
143
|
+
export type MathExpressionScalarCompute = Pick<MathExpressionSignature, "computeBinary" | "computeUnary">;
|
|
144
|
+
//#endregion
|
|
145
|
+
//#region src/models/parser/MathExpressionBinaryOperator.d.ts
|
|
146
|
+
export interface MathExpressionBinaryFunctionOperator {
|
|
147
|
+
name: string;
|
|
148
|
+
power: number;
|
|
149
|
+
type: MathExpressionNodeType.Binary;
|
|
150
|
+
}
|
|
151
|
+
export type MathExpressionBinaryOperator = MathExpressionBinaryFunctionOperator | {
|
|
152
|
+
name: string;
|
|
153
|
+
power: number;
|
|
154
|
+
type: MathExpressionNodeType.Comparison;
|
|
155
|
+
} | {
|
|
156
|
+
operator: MathExpressionLogicalOperator;
|
|
157
|
+
power: number;
|
|
158
|
+
type: MathExpressionNodeType.Logical;
|
|
159
|
+
};
|
|
160
|
+
//#endregion
|
|
161
|
+
//#region src/models/parser/MathExpressionGrammarRule.d.ts
|
|
162
|
+
export declare enum MathExpressionGrammarRule {
|
|
163
|
+
Assignment = "Assignment",
|
|
164
|
+
Binary = "Binary",
|
|
165
|
+
Conditional = "Conditional",
|
|
166
|
+
DivisionBeforeProduct = "DivisionBeforeProduct",
|
|
167
|
+
ImplicitProduct = "ImplicitProduct",
|
|
168
|
+
LeftHand = "LeftHand",
|
|
169
|
+
Nullish = "Nullish",
|
|
170
|
+
Percentage = "Percentage",
|
|
171
|
+
Power = "Power",
|
|
172
|
+
Symbol = "Symbol",
|
|
173
|
+
Unary = "Unary"
|
|
174
|
+
}
|
|
175
|
+
//#endregion
|
|
176
|
+
//#region src/models/parser/MathExpressionTokenType.d.ts
|
|
177
|
+
export declare enum MathExpressionTokenType {
|
|
178
|
+
Delimiter = "delimiter",
|
|
179
|
+
Null = "null",
|
|
180
|
+
Number = "number",
|
|
181
|
+
Symbol = "symbol",
|
|
182
|
+
Unknown = "unknown"
|
|
183
|
+
}
|
|
184
|
+
//#endregion
|
|
185
|
+
//#region src/models/shared/MathExpressionError.d.ts
|
|
186
|
+
export declare class MathExpressionError extends Error {
|
|
187
|
+
constructor(message: string);
|
|
188
|
+
}
|
|
189
|
+
//#endregion
|
|
190
|
+
//#region src/models/parser/MathExpressionParserState.d.ts
|
|
191
|
+
export interface MathExpressionParserState {
|
|
192
|
+
depth: number;
|
|
193
|
+
error: MathExpressionError | null;
|
|
194
|
+
index: number;
|
|
195
|
+
nestingLevel: number;
|
|
196
|
+
source: string;
|
|
197
|
+
token: string;
|
|
198
|
+
tokenType: MathExpressionTokenType;
|
|
199
|
+
}
|
|
200
|
+
//#endregion
|
|
201
|
+
//#region src/models/parser/MathExpressionParse.d.ts
|
|
202
|
+
export type MathExpressionParse = (state: MathExpressionParserState, rule: MathExpressionGrammarRule) => MathExpressionNode;
|
|
203
|
+
//#endregion
|
|
204
|
+
//#region src/models/parser/MathExpressionRuleParser.d.ts
|
|
205
|
+
export type MathExpressionRuleParser = (state: MathExpressionParserState, parse: MathExpressionParse) => MathExpressionNode;
|
|
206
|
+
//#endregion
|
|
207
|
+
//#region src/services/compiler/MathExpressionBitwiseAbsorptionMap.d.ts
|
|
208
|
+
export declare const MathExpressionBitwiseAbsorptionMap: Readonly<Record<string, {
|
|
209
|
+
absorbs: number;
|
|
210
|
+
result: number;
|
|
211
|
+
}>>;
|
|
212
|
+
//#endregion
|
|
213
|
+
//#region src/services/compiler/MathExpressionNodeCompileMap.d.ts
|
|
214
|
+
export declare const MathExpressionNodeCompileMap: { [T in MathExpressionNodeType]: (node: Extract<MathExpressionNode, {
|
|
215
|
+
type: T;
|
|
216
|
+
}>, context: MathExpressionCompileContext) => MathExpressionCompiled; };
|
|
217
|
+
//#endregion
|
|
218
|
+
//#region src/services/compiler/checkIsPercentageExpression.d.ts
|
|
219
|
+
export declare const checkIsPercentageExpression: (node: MathExpressionNode) => boolean;
|
|
220
|
+
//#endregion
|
|
221
|
+
//#region src/services/compiler/collectMathExpressionAssignedNames.d.ts
|
|
222
|
+
export declare const collectMathExpressionAssignedNames: (node: MathExpressionNode, names: Set<string>) => void;
|
|
223
|
+
//#endregion
|
|
224
|
+
//#region src/services/compiler/compileArgument.d.ts
|
|
225
|
+
export declare const compileArgument: (node: MathExpressionNode, context: MathExpressionCompileContext) => MathExpressionCompiledArgument;
|
|
226
|
+
//#endregion
|
|
227
|
+
//#region src/services/compiler/compileList.d.ts
|
|
228
|
+
export declare const compileList: (elements: MathExpressionNode[], context: MathExpressionCompileContext) => MathExpressionCompiledArgument;
|
|
229
|
+
//#endregion
|
|
230
|
+
//#region src/services/compiler/compileMathExpression.d.ts
|
|
231
|
+
export declare const compileMathExpression: (node: MathExpressionNode, variableNames: readonly string[]) => ((values: readonly number[]) => number);
|
|
232
|
+
//#endregion
|
|
233
|
+
//#region src/services/compiler/compileMathExpressionNode.d.ts
|
|
234
|
+
export declare const compileMathExpressionNode: (node: MathExpressionNode, context: MathExpressionCompileContext) => MathExpressionCompiled;
|
|
235
|
+
//#endregion
|
|
236
|
+
//#region src/services/compiler/constants.d.ts
|
|
237
|
+
export declare const NO_VALUES: readonly number[];
|
|
238
|
+
export declare const NO_LOCALS: MathExpressionResult[];
|
|
239
|
+
export declare const ADDITIVE_NAMES: readonly string[];
|
|
240
|
+
//#endregion
|
|
241
|
+
//#region src/services/compiler/getMathExpressionConstant.d.ts
|
|
242
|
+
export declare const getMathExpressionConstant: (name: string) => number | undefined;
|
|
243
|
+
//#endregion
|
|
244
|
+
//#region src/services/compiler/getMathExpressionOuterValue.d.ts
|
|
245
|
+
export declare const getMathExpressionOuterValue: (outer: MathExpressionOuterBinding, values: readonly number[]) => MathExpressionResult;
|
|
246
|
+
//#endregion
|
|
247
|
+
//#region src/services/compiler/getMathExpressionScalarCompute.d.ts
|
|
248
|
+
export declare const getMathExpressionScalarCompute: <Key extends keyof MathExpressionScalarCompute>(name: string, key: Key) => NonNullable<MathExpressionScalarCompute[Key]>;
|
|
249
|
+
//#endregion
|
|
250
|
+
//#region src/services/compiler/node/compileAssignment.d.ts
|
|
251
|
+
export declare const compileAssignment: (node: Extract<MathExpressionNode, {
|
|
252
|
+
type: MathExpressionNodeType.Assignment;
|
|
253
|
+
}>, context: MathExpressionCompileContext) => MathExpressionCompiled;
|
|
254
|
+
//#endregion
|
|
255
|
+
//#region src/services/compiler/node/compileBinary.d.ts
|
|
256
|
+
export declare const compileBinary: (node: Extract<MathExpressionNode, {
|
|
257
|
+
type: MathExpressionNodeType.Binary;
|
|
258
|
+
}>, context: MathExpressionCompileContext) => MathExpressionCompiled;
|
|
259
|
+
//#endregion
|
|
260
|
+
//#region src/services/compiler/node/compileCall.d.ts
|
|
261
|
+
export declare const compileCall: (node: Extract<MathExpressionNode, {
|
|
262
|
+
type: MathExpressionNodeType.Call;
|
|
263
|
+
}>, context: MathExpressionCompileContext) => MathExpressionCompiled;
|
|
264
|
+
//#endregion
|
|
265
|
+
//#region src/services/compiler/node/compileComparison.d.ts
|
|
266
|
+
export declare const compileComparison: (node: Extract<MathExpressionNode, {
|
|
267
|
+
type: MathExpressionNodeType.Comparison;
|
|
268
|
+
}>, context: MathExpressionCompileContext) => MathExpressionCompiled;
|
|
269
|
+
//#endregion
|
|
270
|
+
//#region src/services/compiler/node/compileConditional.d.ts
|
|
271
|
+
export declare const compileConditional: (node: Extract<MathExpressionNode, {
|
|
272
|
+
type: MathExpressionNodeType.Conditional;
|
|
273
|
+
}>, context: MathExpressionCompileContext) => MathExpressionCompiled;
|
|
274
|
+
//#endregion
|
|
275
|
+
//#region src/services/compiler/node/compileGroup.d.ts
|
|
276
|
+
export declare const compileGroup: (node: Extract<MathExpressionNode, {
|
|
277
|
+
type: MathExpressionNodeType.Group;
|
|
278
|
+
}>, context: MathExpressionCompileContext) => MathExpressionCompiled;
|
|
279
|
+
//#endregion
|
|
280
|
+
//#region src/services/compiler/node/compileListNode.d.ts
|
|
281
|
+
export declare const compileListNode: () => MathExpressionCompiled;
|
|
282
|
+
//#endregion
|
|
283
|
+
//#region src/services/compiler/node/compileLogical.d.ts
|
|
284
|
+
export declare const compileLogical: (node: Extract<MathExpressionNode, {
|
|
285
|
+
type: MathExpressionNodeType.Logical;
|
|
286
|
+
}>, context: MathExpressionCompileContext) => MathExpressionCompiled;
|
|
287
|
+
//#endregion
|
|
288
|
+
//#region src/services/compiler/node/compileName.d.ts
|
|
289
|
+
export declare const compileName: (node: Extract<MathExpressionNode, {
|
|
290
|
+
type: MathExpressionNodeType.Name;
|
|
291
|
+
}>, context: MathExpressionCompileContext) => MathExpressionCompiled;
|
|
292
|
+
//#endregion
|
|
293
|
+
//#region src/services/compiler/node/compileNumber.d.ts
|
|
294
|
+
export declare const compileNumber: (node: Extract<MathExpressionNode, {
|
|
295
|
+
type: MathExpressionNodeType.Number;
|
|
296
|
+
}>) => MathExpressionCompiled;
|
|
297
|
+
//#endregion
|
|
298
|
+
//#region src/services/compiler/node/compilePercentage.d.ts
|
|
299
|
+
export declare const compilePercentage: (node: Extract<MathExpressionNode, {
|
|
300
|
+
type: MathExpressionNodeType.Percentage;
|
|
301
|
+
}>, context: MathExpressionCompileContext) => MathExpressionCompiled;
|
|
302
|
+
//#endregion
|
|
303
|
+
//#region src/services/compiler/node/compileUnary.d.ts
|
|
304
|
+
export declare const compileUnary: (node: Extract<MathExpressionNode, {
|
|
305
|
+
type: MathExpressionNodeType.Unary;
|
|
306
|
+
}>, context: MathExpressionCompileContext) => MathExpressionCompiled;
|
|
307
|
+
//#endregion
|
|
308
|
+
//#region src/services/function/MathExpressionFunctionMap.d.ts
|
|
309
|
+
export declare const MathExpressionFunctionMap: Record<string, MathExpressionSignature[]>;
|
|
310
|
+
//#endregion
|
|
311
|
+
//#region src/services/function/checkIsLarger.d.ts
|
|
312
|
+
export declare const checkIsLarger: (left: number, right: number) => boolean;
|
|
313
|
+
//#endregion
|
|
314
|
+
//#region src/services/function/checkIsMillerRabinPassing.d.ts
|
|
315
|
+
export declare const checkIsMillerRabinPassing: (candidate: bigint, base: bigint, oddPart: bigint, twos: number) => boolean;
|
|
316
|
+
//#endregion
|
|
317
|
+
//#region src/services/function/checkIsNearlyEqual.d.ts
|
|
318
|
+
export declare const checkIsNearlyEqual: (left: number, right: number) => boolean;
|
|
319
|
+
//#endregion
|
|
320
|
+
//#region src/services/function/checkIsPrime.d.ts
|
|
321
|
+
export declare const checkIsPrime: (value: number) => boolean;
|
|
322
|
+
//#endregion
|
|
323
|
+
//#region src/services/function/checkIsSmaller.d.ts
|
|
324
|
+
export declare const checkIsSmaller: (left: number, right: number) => boolean;
|
|
325
|
+
//#endregion
|
|
326
|
+
//#region src/services/function/compareNumbers.d.ts
|
|
327
|
+
export declare const compareNumbers: (left: number, right: number) => number;
|
|
328
|
+
//#endregion
|
|
329
|
+
//#region src/services/function/computeBellNumber.d.ts
|
|
330
|
+
export declare const computeBellNumber: (index: number) => null | number;
|
|
331
|
+
//#endregion
|
|
332
|
+
//#region src/services/function/computeBernoulliNumber.d.ts
|
|
333
|
+
export declare const computeBernoulliNumber: (index: number) => number;
|
|
334
|
+
//#endregion
|
|
335
|
+
//#region src/services/function/computeBitwiseAnd.d.ts
|
|
336
|
+
export declare const computeBitwiseAnd: (left: number, right: number) => number;
|
|
337
|
+
//#endregion
|
|
338
|
+
//#region src/services/function/computeBitwiseOr.d.ts
|
|
339
|
+
export declare const computeBitwiseOr: (left: number, right: number) => number;
|
|
340
|
+
//#endregion
|
|
341
|
+
//#region src/services/function/computeCatalan.d.ts
|
|
342
|
+
export declare const computeCatalan: (index: number) => null | number;
|
|
343
|
+
//#endregion
|
|
344
|
+
//#region src/services/function/computeCombinations.d.ts
|
|
345
|
+
export declare const computeCombinations: (available: number, chosen: number) => number;
|
|
346
|
+
//#endregion
|
|
347
|
+
//#region src/services/function/computeComparison.d.ts
|
|
348
|
+
export declare const computeComparison: (left: number, right: number) => number;
|
|
349
|
+
//#endregion
|
|
350
|
+
//#region src/services/function/computeCompositions.d.ts
|
|
351
|
+
export declare const computeCompositions: (total: number, parts: number) => null | number;
|
|
352
|
+
//#endregion
|
|
353
|
+
//#region src/services/function/computeCorrelation.d.ts
|
|
354
|
+
export declare const computeCorrelation: (left: readonly number[], right: readonly number[]) => null | number;
|
|
355
|
+
//#endregion
|
|
356
|
+
//#region src/services/function/computeDeterminant.d.ts
|
|
357
|
+
export declare const computeDeterminant: (values: readonly number[]) => null | number;
|
|
358
|
+
//#endregion
|
|
359
|
+
//#region src/services/function/computeDistance.d.ts
|
|
360
|
+
export declare const computeDistance: (point: number[], other: number[]) => null | number;
|
|
361
|
+
//#endregion
|
|
362
|
+
//#region src/services/function/computeDotProduct.d.ts
|
|
363
|
+
export declare const computeDotProduct: (left: readonly number[], right: readonly number[]) => null | number;
|
|
364
|
+
//#endregion
|
|
365
|
+
//#region src/services/function/computeErf.d.ts
|
|
366
|
+
export declare const computeErf: (value: number) => number;
|
|
367
|
+
//#endregion
|
|
368
|
+
//#region src/services/function/computeErfInverse.d.ts
|
|
369
|
+
export declare const computeErfInverse: (value: number) => number;
|
|
370
|
+
//#endregion
|
|
371
|
+
//#region src/services/function/computeExtreme.d.ts
|
|
372
|
+
export declare const computeExtreme: (values: readonly number[], initial: number, checkIsPreferred: (value: number, extreme: number) => boolean) => number;
|
|
373
|
+
//#endregion
|
|
374
|
+
//#region src/services/function/computeFactorial.d.ts
|
|
375
|
+
export declare const computeFactorial: (value: number) => null | number;
|
|
376
|
+
//#endregion
|
|
377
|
+
//#region src/services/function/computeGamma.d.ts
|
|
378
|
+
export declare const computeGamma: (value: number) => number;
|
|
379
|
+
//#endregion
|
|
380
|
+
//#region src/services/function/computeGreatestCommonDivisor.d.ts
|
|
381
|
+
export declare const computeGreatestCommonDivisor: (left: number, right: number) => number;
|
|
382
|
+
//#endregion
|
|
383
|
+
//#region src/services/function/computeHypotenuse.d.ts
|
|
384
|
+
export declare const computeHypotenuse: (values: readonly number[]) => number;
|
|
385
|
+
//#endregion
|
|
386
|
+
//#region src/services/function/computeInitialGuess.d.ts
|
|
387
|
+
export declare const computeInitialGuess: (value: number) => number;
|
|
388
|
+
//#endregion
|
|
389
|
+
//#region src/services/function/computeIntegerGreatestCommonDivisor.d.ts
|
|
390
|
+
export declare const computeIntegerGreatestCommonDivisor: (values: readonly number[]) => null | number;
|
|
391
|
+
//#endregion
|
|
392
|
+
//#region src/services/function/computeInverseCoth.d.ts
|
|
393
|
+
export declare const computeInverseCoth: (value: number) => number;
|
|
394
|
+
//#endregion
|
|
395
|
+
//#region src/services/function/computeKullbackLeibler.d.ts
|
|
396
|
+
export declare const computeKullbackLeibler: (distribution: readonly number[], reference: readonly number[]) => null | number;
|
|
397
|
+
//#endregion
|
|
398
|
+
//#region src/services/function/computeLeastCommonMultiple.d.ts
|
|
399
|
+
export declare const computeLeastCommonMultiple: (left: number, right: number) => null | number;
|
|
400
|
+
//#endregion
|
|
401
|
+
//#region src/services/function/computeListComparison.d.ts
|
|
402
|
+
export declare const computeListComparison: (left: number[], right: number[]) => number;
|
|
403
|
+
//#endregion
|
|
404
|
+
//#region src/services/function/computeLogGamma.d.ts
|
|
405
|
+
export declare const computeLogGamma: (value: number) => number;
|
|
406
|
+
//#endregion
|
|
407
|
+
//#region src/services/function/computeLogGammaOfPositive.d.ts
|
|
408
|
+
export declare const computeLogGammaOfPositive: (value: number) => {
|
|
409
|
+
logGamma: number;
|
|
410
|
+
product: number;
|
|
411
|
+
};
|
|
412
|
+
//#endregion
|
|
413
|
+
//#region src/services/function/computeLogarithm.d.ts
|
|
414
|
+
export declare const computeLogarithm: (value: number, base?: number) => number;
|
|
415
|
+
//#endregion
|
|
416
|
+
//#region src/services/function/computeMean.d.ts
|
|
417
|
+
export declare const computeMean: (values: readonly number[]) => number;
|
|
418
|
+
//#endregion
|
|
419
|
+
//#region src/services/function/computeMedian.d.ts
|
|
420
|
+
export declare const computeMedian: (values: readonly number[]) => number;
|
|
421
|
+
//#endregion
|
|
422
|
+
//#region src/services/function/computeMedianAbsoluteDeviation.d.ts
|
|
423
|
+
export declare const computeMedianAbsoluteDeviation: (values: readonly number[]) => number;
|
|
424
|
+
//#endregion
|
|
425
|
+
//#region src/services/function/computeModularInverse.d.ts
|
|
426
|
+
export declare const computeModularInverse: (value: number, modulus: number) => null | number;
|
|
427
|
+
//#endregion
|
|
428
|
+
//#region src/services/function/computeModularPower.d.ts
|
|
429
|
+
export declare const computeModularPower: (base: bigint, exponent: bigint, modulus: bigint) => bigint;
|
|
430
|
+
//#endregion
|
|
431
|
+
//#region src/services/function/computeModulo.d.ts
|
|
432
|
+
export declare const computeModulo: (dividend: number, divisor: number) => number;
|
|
433
|
+
//#endregion
|
|
434
|
+
//#region src/services/function/computeMultinomial.d.ts
|
|
435
|
+
export declare const computeMultinomial: (parts: readonly number[]) => null | number;
|
|
436
|
+
//#endregion
|
|
437
|
+
//#region src/services/function/computeNorm.d.ts
|
|
438
|
+
export declare const computeNorm: (values: readonly number[]) => null | number;
|
|
439
|
+
//#endregion
|
|
440
|
+
//#region src/services/function/computeNthRoot.d.ts
|
|
441
|
+
export declare const computeNthRoot: (value: number, root: number) => null | number;
|
|
442
|
+
//#endregion
|
|
443
|
+
//#region src/services/function/computePartitionSelect.d.ts
|
|
444
|
+
export declare const computePartitionSelect: (values: number[], index: number) => null | number;
|
|
445
|
+
//#endregion
|
|
446
|
+
//#region src/services/function/computePermutations.d.ts
|
|
447
|
+
export declare const computePermutations: (available: number, chosen: number) => null | number;
|
|
448
|
+
//#endregion
|
|
449
|
+
//#region src/services/function/computePointToLine2D.d.ts
|
|
450
|
+
export declare const computePointToLine2D: (point: number[], line: number[]) => number;
|
|
451
|
+
//#endregion
|
|
452
|
+
//#region src/services/function/computePointToLine3D.d.ts
|
|
453
|
+
export declare const computePointToLine3D: (point: number[], line: number[]) => number;
|
|
454
|
+
//#endregion
|
|
455
|
+
//#region src/services/function/computePolynomial.d.ts
|
|
456
|
+
export declare const computePolynomial: (leading: number, coefficients: readonly number[], variable: number) => number;
|
|
457
|
+
//#endregion
|
|
458
|
+
//#region src/services/function/computeProduct.d.ts
|
|
459
|
+
export declare const computeProduct: (values: readonly MathExpressionValue[]) => null | number;
|
|
460
|
+
//#endregion
|
|
461
|
+
//#region src/services/function/computeProductOfRange.d.ts
|
|
462
|
+
export declare const computeProductOfRange: (first: number, last: number) => number;
|
|
463
|
+
//#endregion
|
|
464
|
+
//#region src/services/function/computeQuantile.d.ts
|
|
465
|
+
export declare const computeQuantile: (values: number[], probability: number, isSorted: boolean) => null | number;
|
|
466
|
+
//#endregion
|
|
467
|
+
//#region src/services/function/computeStirlingColumn.d.ts
|
|
468
|
+
export declare const computeStirlingColumn: (count: number, parts: number) => number;
|
|
469
|
+
//#endregion
|
|
470
|
+
//#region src/services/function/computeStirlingDiagonal.d.ts
|
|
471
|
+
export declare const computeStirlingDiagonal: (count: number, index: number) => number;
|
|
472
|
+
//#endregion
|
|
473
|
+
//#region src/services/function/computeStirlingLogGamma.d.ts
|
|
474
|
+
export declare const computeStirlingLogGamma: (value: number) => number;
|
|
475
|
+
//#endregion
|
|
476
|
+
//#region src/services/function/computeStirlingSecondKind.d.ts
|
|
477
|
+
export declare const computeStirlingSecondKind: (count: number, parts: number) => null | number;
|
|
478
|
+
//#endregion
|
|
479
|
+
//#region src/services/function/computeSum.d.ts
|
|
480
|
+
export declare const computeSum: (values: readonly number[]) => number;
|
|
481
|
+
//#endregion
|
|
482
|
+
//#region src/services/function/computeSummedZeta.d.ts
|
|
483
|
+
export declare const computeSummedZeta: (value: number) => number;
|
|
484
|
+
//#endregion
|
|
485
|
+
//#region src/services/function/computeTruthyCount.d.ts
|
|
486
|
+
export declare const computeTruthyCount: (values: readonly number[]) => number;
|
|
487
|
+
//#endregion
|
|
488
|
+
//#region src/services/function/computeVariance.d.ts
|
|
489
|
+
export declare const computeVariance: (values: readonly number[]) => number;
|
|
490
|
+
//#endregion
|
|
491
|
+
//#region src/services/function/computeVectorNorm.d.ts
|
|
492
|
+
export declare const computeVectorNorm: (values: readonly number[], power: number) => null | number;
|
|
493
|
+
//#endregion
|
|
494
|
+
//#region src/services/function/computeZeta.d.ts
|
|
495
|
+
export declare const computeZeta: (value: number) => number;
|
|
496
|
+
//#endregion
|
|
497
|
+
//#region src/services/function/constants.d.ts
|
|
498
|
+
export declare const MATH_EXPRESSION_RELATIVE_TOLERANCE = 1e-12;
|
|
499
|
+
export declare const MATH_EXPRESSION_ABSOLUTE_TOLERANCE = 1e-15;
|
|
500
|
+
export declare const SQRT_PI: number;
|
|
501
|
+
export declare const BERNOULLI_CLOSED_FORM_INDEX = 54;
|
|
502
|
+
export declare const MAXIMUM_DIGITS = 15;
|
|
503
|
+
export declare const MAXIMUM_STIRLING_WORK = 4e6;
|
|
504
|
+
export declare const MILLER_RABIN_BASES: readonly bigint[];
|
|
505
|
+
export declare const REFINEMENT_STEPS = 4;
|
|
506
|
+
export declare const LOW_TAIL_COEFFICIENTS: readonly number[];
|
|
507
|
+
export declare const HIGH_TAIL_COEFFICIENTS: readonly number[];
|
|
508
|
+
export declare const OVERFLOW_ARGUMENT = 171.35;
|
|
509
|
+
export declare const LAST_FACTORIAL_ARGUMENT = 171;
|
|
510
|
+
export declare const STIRLING_THRESHOLD = 15;
|
|
511
|
+
export declare const STIRLING_TERMS: readonly number[];
|
|
512
|
+
export declare const EULER_MACLAURIN_COEFFICIENTS: readonly number[];
|
|
513
|
+
export declare const SUMMATION_LIMIT = 10;
|
|
514
|
+
//#endregion
|
|
515
|
+
//#region src/services/function/multiplyPair.d.ts
|
|
516
|
+
export declare const multiplyPair: (left: MathExpressionValue, right: MathExpressionValue) => MathExpressionValue | null;
|
|
517
|
+
//#endregion
|
|
518
|
+
//#region src/services/function/roundToDigits.d.ts
|
|
519
|
+
export declare const roundToDigits: (rounder: (value: number) => number, value: number, digits: number) => null | number;
|
|
520
|
+
//#endregion
|
|
521
|
+
//#region src/services/function/scaleList.d.ts
|
|
522
|
+
export declare const scaleList: (list: number[], scalar: number) => number[];
|
|
523
|
+
//#endregion
|
|
524
|
+
//#region src/services/function/shiftDecimalPlaces.d.ts
|
|
525
|
+
export declare const shiftDecimalPlaces: (value: number, places: number) => number;
|
|
526
|
+
//#endregion
|
|
527
|
+
//#region src/services/function/signature/createBinarySignatures.d.ts
|
|
528
|
+
export declare const createBinarySignatures: (compute: MathExpressionBinaryCompute) => MathExpressionSignature[];
|
|
529
|
+
//#endregion
|
|
530
|
+
//#region src/services/function/signature/createBitwiseFold.d.ts
|
|
531
|
+
export declare const createBitwiseFold: (absorbing: number, compute: (left: number, right: number) => number) => MathExpressionNumberCompute;
|
|
532
|
+
//#endregion
|
|
533
|
+
//#region src/services/function/signature/createBitwisePair.d.ts
|
|
534
|
+
export declare const createBitwisePair: (absorbing: number, compute: (left: number, right: number) => number) => MathExpressionBinaryCompute;
|
|
535
|
+
//#endregion
|
|
536
|
+
//#region src/services/function/signature/createDigitSignatures.d.ts
|
|
537
|
+
export declare const createDigitSignatures: (rounder: (value: number) => number) => MathExpressionSignature[];
|
|
538
|
+
//#endregion
|
|
539
|
+
//#region src/services/function/signature/createExtremeSignatures.d.ts
|
|
540
|
+
export declare const createExtremeSignatures: (checkIsPreferred: (value: number, extreme: number) => boolean) => MathExpressionSignature[];
|
|
541
|
+
//#endregion
|
|
542
|
+
//#region src/services/function/signature/createIdentitySignatures.d.ts
|
|
543
|
+
export declare const createIdentitySignatures: () => MathExpressionSignature[];
|
|
544
|
+
//#endregion
|
|
545
|
+
//#region src/services/function/signature/createIntegerBinarySignatures.d.ts
|
|
546
|
+
export declare const createIntegerBinarySignatures: (compute: (left: number, right: number) => null | number) => MathExpressionSignature[];
|
|
547
|
+
//#endregion
|
|
548
|
+
//#region src/services/function/signature/createIntegerUnarySignatures.d.ts
|
|
549
|
+
export declare const createIntegerUnarySignatures: (compute: (value: number) => null | number) => MathExpressionSignature[];
|
|
550
|
+
//#endregion
|
|
551
|
+
//#region src/services/function/signature/createListFirstCompute.d.ts
|
|
552
|
+
export declare const createListFirstCompute: (compute: (list: number[], numbers: number[]) => null | number) => MathExpressionSignature["compute"];
|
|
553
|
+
//#endregion
|
|
554
|
+
//#region src/services/function/signature/createListPairCompute.d.ts
|
|
555
|
+
export declare const createListPairCompute: (compute: (left: number[], right: number[]) => null | number) => MathExpressionSignature["compute"];
|
|
556
|
+
//#endregion
|
|
557
|
+
//#region src/services/function/signature/createListPairSignature.d.ts
|
|
558
|
+
export declare const createListPairSignature: (compute: (left: number[], right: number[]) => null | number) => MathExpressionSignature;
|
|
559
|
+
//#endregion
|
|
560
|
+
//#region src/services/function/signature/createListSignature.d.ts
|
|
561
|
+
export declare const createListSignature: (compute: MathExpressionNumberCompute) => MathExpressionSignature;
|
|
562
|
+
//#endregion
|
|
563
|
+
//#region src/services/function/signature/createNonEmptyCompute.d.ts
|
|
564
|
+
export declare const createNonEmptyCompute: (compute: (values: readonly number[]) => number) => MathExpressionNumberCompute;
|
|
565
|
+
//#endregion
|
|
566
|
+
//#region src/services/function/signature/createNumberSignature.d.ts
|
|
567
|
+
export declare const createNumberSignature: (minArity: number, maxArity: number, compute: MathExpressionNumberCompute, scalarCompute?: MathExpressionScalarCompute) => MathExpressionSignature;
|
|
568
|
+
//#endregion
|
|
569
|
+
//#region src/services/function/signature/createNumericCompute.d.ts
|
|
570
|
+
export declare const createNumericCompute: (compute: MathExpressionNumberCompute) => MathExpressionSignature["compute"];
|
|
571
|
+
//#endregion
|
|
572
|
+
//#region src/services/function/signature/createOrderedListSignatures.d.ts
|
|
573
|
+
export declare const createOrderedListSignatures: (compute: (left: number[], right: number[]) => null | number) => MathExpressionSignature[];
|
|
574
|
+
//#endregion
|
|
575
|
+
//#region src/services/function/signature/createRangedSignatures.d.ts
|
|
576
|
+
export declare const createRangedSignatures: (minArity: number, maxArity: number, compute: MathExpressionNumberCompute, scalarCompute?: MathExpressionScalarCompute) => MathExpressionSignature[];
|
|
577
|
+
//#endregion
|
|
578
|
+
//#region src/services/function/signature/createSignature.d.ts
|
|
579
|
+
export declare const createSignature: (parameters: MathExpressionParameterType[], minArity: number, maxArity: number, compute: MathExpressionSignature["compute"], scalarCompute?: MathExpressionScalarCompute) => MathExpressionSignature;
|
|
580
|
+
//#endregion
|
|
581
|
+
//#region src/services/function/signature/createSingletonListSignature.d.ts
|
|
582
|
+
export declare const createSingletonListSignature: (compute: MathExpressionUnaryCompute) => MathExpressionSignature;
|
|
583
|
+
//#endregion
|
|
584
|
+
//#region src/services/function/signature/createSpreadSignatures.d.ts
|
|
585
|
+
export declare const createSpreadSignatures: (minArity: number, compute: MathExpressionNumberCompute) => MathExpressionSignature[];
|
|
586
|
+
//#endregion
|
|
587
|
+
//#region src/services/function/signature/createUnarySignatures.d.ts
|
|
588
|
+
export declare const createUnarySignatures: (compute: MathExpressionUnaryCompute) => MathExpressionSignature[];
|
|
589
|
+
//#endregion
|
|
590
|
+
//#region src/services/function/signature/createVariadicSignatures.d.ts
|
|
591
|
+
export declare const createVariadicSignatures: (minArity: number, compute: MathExpressionNumberCompute, computeBinary?: MathExpressionBinaryCompute) => MathExpressionSignature[];
|
|
592
|
+
//#endregion
|
|
593
|
+
//#region src/services/names/getMathExpressionNames.d.ts
|
|
594
|
+
export declare const getMathExpressionNames: (node: MathExpressionNode) => string[];
|
|
595
|
+
//#endregion
|
|
596
|
+
//#region src/services/names/walkNode.d.ts
|
|
597
|
+
export declare const walkNode: (node: MathExpressionNode, bound: Set<string>, free: Set<string>) => void;
|
|
598
|
+
//#endregion
|
|
599
|
+
//#region src/services/parser/MathExpressionBinaryOperatorMap.d.ts
|
|
600
|
+
export declare const MathExpressionBinaryOperatorMap: {
|
|
601
|
+
readonly "*": MathExpressionBinaryFunctionOperator;
|
|
602
|
+
readonly "/": MathExpressionBinaryFunctionOperator;
|
|
603
|
+
readonly [token: string]: MathExpressionBinaryOperator;
|
|
604
|
+
};
|
|
605
|
+
//#endregion
|
|
606
|
+
//#region src/services/parser/MathExpressionOperatorMap.d.ts
|
|
607
|
+
export declare const MathExpressionOperatorMap: {
|
|
608
|
+
[MathExpressionGrammarRule.Nullish]: Readonly<Record<string, MathExpressionLogicalOperator>>;
|
|
609
|
+
[MathExpressionGrammarRule.Power]: Readonly<Record<string, string>>;
|
|
610
|
+
[MathExpressionGrammarRule.Unary]: Readonly<Record<string, string>>;
|
|
611
|
+
};
|
|
612
|
+
//#endregion
|
|
613
|
+
//#region src/services/parser/MathExpressionRuleParserMap.d.ts
|
|
614
|
+
export declare const MathExpressionRuleParserMap: Record<MathExpressionGrammarRule, MathExpressionRuleParser>;
|
|
615
|
+
//#endregion
|
|
616
|
+
//#region src/services/parser/checkCanMathExpressionNest.d.ts
|
|
617
|
+
export declare const checkCanMathExpressionNest: (state: MathExpressionParserState) => boolean;
|
|
618
|
+
//#endregion
|
|
619
|
+
//#region src/services/parser/checkIsNameToken.d.ts
|
|
620
|
+
export declare const checkIsNameToken: (state: MathExpressionParserState) => boolean;
|
|
621
|
+
//#endregion
|
|
622
|
+
//#region src/services/parser/checkIsOperatorOperand.d.ts
|
|
623
|
+
export declare const checkIsOperatorOperand: (node: MathExpressionNode) => boolean;
|
|
624
|
+
//#endregion
|
|
625
|
+
//#region src/services/parser/checkIsSignedNumber.d.ts
|
|
626
|
+
export declare const checkIsSignedNumber: (node: MathExpressionNode) => boolean;
|
|
627
|
+
//#endregion
|
|
628
|
+
//#region src/services/parser/checkIsToken.d.ts
|
|
629
|
+
export declare const checkIsToken: (state: MathExpressionParserState, token: string) => boolean;
|
|
630
|
+
//#endregion
|
|
631
|
+
//#region src/services/parser/checkIsUnaryStart.d.ts
|
|
632
|
+
export declare const checkIsUnaryStart: (state: MathExpressionParserState) => boolean;
|
|
633
|
+
//#endregion
|
|
634
|
+
//#region src/services/parser/computeNumberLiteral.d.ts
|
|
635
|
+
export declare const computeNumberLiteral: (token: string) => null | number;
|
|
636
|
+
//#endregion
|
|
637
|
+
//#region src/services/parser/constants.d.ts
|
|
638
|
+
export declare const MAX_MATH_EXPRESSION_DEPTH = 64;
|
|
639
|
+
export declare const PLACEHOLDER: MathExpressionNode;
|
|
640
|
+
//#endregion
|
|
641
|
+
//#region src/services/parser/createBinaryNode.d.ts
|
|
642
|
+
export declare const createBinaryNode: (left: MathExpressionNode, name: string, right: MathExpressionNode) => MathExpressionNode;
|
|
643
|
+
//#endregion
|
|
644
|
+
//#region src/services/parser/createBinaryOperation.d.ts
|
|
645
|
+
export declare const createBinaryOperation: (left: MathExpressionNode, operator: MathExpressionBinaryOperator, right: MathExpressionNode) => MathExpressionNode;
|
|
646
|
+
//#endregion
|
|
647
|
+
//#region src/services/parser/createLogicalNode.d.ts
|
|
648
|
+
export declare const createLogicalNode: (left: MathExpressionNode, operator: MathExpressionLogicalOperator, right: MathExpressionNode) => MathExpressionNode;
|
|
649
|
+
//#endregion
|
|
650
|
+
//#region src/services/parser/failMathExpression.d.ts
|
|
651
|
+
export declare const failMathExpression: (state: MathExpressionParserState, message: string) => void;
|
|
652
|
+
//#endregion
|
|
653
|
+
//#region src/services/parser/failMathExpressionAt.d.ts
|
|
654
|
+
export declare const failMathExpressionAt: (state: MathExpressionParserState, message: string, column: number) => void;
|
|
655
|
+
//#endregion
|
|
656
|
+
//#region src/services/parser/getArgumentCountText.d.ts
|
|
657
|
+
export declare const getArgumentCountText: (count: number) => string;
|
|
658
|
+
//#endregion
|
|
659
|
+
//#region src/services/parser/getMathExpressionArityMessage.d.ts
|
|
660
|
+
export declare const getMathExpressionArityMessage: (name: string, minArity: number, maxArity: number) => string;
|
|
661
|
+
//#endregion
|
|
662
|
+
//#region src/services/parser/getMathExpressionColumn.d.ts
|
|
663
|
+
export declare const getMathExpressionColumn: (state: MathExpressionParserState) => number;
|
|
664
|
+
//#endregion
|
|
665
|
+
//#region src/services/parser/getMathExpressionSignatureError.d.ts
|
|
666
|
+
export declare const getMathExpressionSignatureError: (name: string, signatures: readonly MathExpressionSignature[], parameterTypes: MathExpressionParameterType[]) => string;
|
|
667
|
+
//#endregion
|
|
668
|
+
//#region src/services/parser/getMathExpressionToken.d.ts
|
|
669
|
+
export declare const getMathExpressionToken: (state: MathExpressionParserState) => void;
|
|
670
|
+
//#endregion
|
|
671
|
+
//#region src/services/parser/parseArgument.d.ts
|
|
672
|
+
export declare const parseArgument: (state: MathExpressionParserState, parse: MathExpressionParse) => MathExpressionNode;
|
|
673
|
+
//#endregion
|
|
674
|
+
//#region src/services/parser/parseBinaryOperators.d.ts
|
|
675
|
+
export declare const parseBinaryOperators: (state: MathExpressionParserState, parse: MathExpressionParse, minimumPower: number) => MathExpressionNode;
|
|
676
|
+
//#endregion
|
|
677
|
+
//#region src/services/parser/parseCall.d.ts
|
|
678
|
+
export declare const parseCall: (state: MathExpressionParserState, name: string, column: number, parse: MathExpressionParse) => MathExpressionNode;
|
|
679
|
+
//#endregion
|
|
680
|
+
//#region src/services/parser/parseList.d.ts
|
|
681
|
+
export declare const parseList: (state: MathExpressionParserState, parse: MathExpressionParse) => MathExpressionNode;
|
|
682
|
+
//#endregion
|
|
683
|
+
//#region src/services/parser/parseMathExpression.d.ts
|
|
684
|
+
export declare const parseMathExpression: (formula: string) => Result<MathExpressionNode, MathExpressionError>;
|
|
685
|
+
//#endregion
|
|
686
|
+
//#region src/services/parser/parseMathExpressionRule.d.ts
|
|
687
|
+
export declare const parseMathExpressionRule: (state: MathExpressionParserState, rule: MathExpressionGrammarRule) => MathExpressionNode;
|
|
688
|
+
//#endregion
|
|
689
|
+
//#region src/services/parser/parseSequence.d.ts
|
|
690
|
+
export declare const parseSequence: (state: MathExpressionParserState, closing: string, parseItem: (state: MathExpressionParserState) => MathExpressionNode) => MathExpressionNode[];
|
|
691
|
+
//#endregion
|
|
692
|
+
//#region src/services/parser/rule/parseAssignment.d.ts
|
|
693
|
+
export declare const parseAssignment: MathExpressionRuleParser;
|
|
694
|
+
//#endregion
|
|
695
|
+
//#region src/services/parser/rule/parseBinary.d.ts
|
|
696
|
+
export declare const parseBinary: MathExpressionRuleParser;
|
|
697
|
+
//#endregion
|
|
698
|
+
//#region src/services/parser/rule/parseConditional.d.ts
|
|
699
|
+
export declare const parseConditional: MathExpressionRuleParser;
|
|
700
|
+
//#endregion
|
|
701
|
+
//#region src/services/parser/rule/parseDivisionBeforeProduct.d.ts
|
|
702
|
+
export declare const parseDivisionBeforeProduct: MathExpressionRuleParser;
|
|
703
|
+
//#endregion
|
|
704
|
+
//#region src/services/parser/rule/parseImplicitProduct.d.ts
|
|
705
|
+
export declare const parseImplicitProduct: MathExpressionRuleParser;
|
|
706
|
+
//#endregion
|
|
707
|
+
//#region src/services/parser/rule/parseLeftHand.d.ts
|
|
708
|
+
export declare const parseLeftHand: MathExpressionRuleParser;
|
|
709
|
+
//#endregion
|
|
710
|
+
//#region src/services/parser/rule/parseNullish.d.ts
|
|
711
|
+
export declare const parseNullish: MathExpressionRuleParser;
|
|
712
|
+
//#endregion
|
|
713
|
+
//#region src/services/parser/rule/parsePercentage.d.ts
|
|
714
|
+
export declare const parsePercentage: MathExpressionRuleParser;
|
|
715
|
+
//#endregion
|
|
716
|
+
//#region src/services/parser/rule/parsePower.d.ts
|
|
717
|
+
export declare const parsePower: MathExpressionRuleParser;
|
|
718
|
+
//#endregion
|
|
719
|
+
//#region src/services/parser/rule/parseSymbol.d.ts
|
|
720
|
+
export declare const parseSymbol: MathExpressionRuleParser;
|
|
721
|
+
//#endregion
|
|
722
|
+
//#region src/services/parser/rule/parseUnary.d.ts
|
|
723
|
+
export declare const parseUnary: MathExpressionRuleParser;
|
|
724
|
+
//#endregion
|
|
725
|
+
//#region src/services/parser/token/MathExpressionRadixMap.d.ts
|
|
726
|
+
export declare const MathExpressionRadixMap: Readonly<Record<string, {
|
|
727
|
+
digit: RegExp;
|
|
728
|
+
radix: number;
|
|
729
|
+
}>>;
|
|
730
|
+
//#endregion
|
|
731
|
+
//#region src/services/parser/token/checkIsDecimalMark.d.ts
|
|
732
|
+
export declare const checkIsDecimalMark: (character: string, nextCharacter: string) => boolean;
|
|
733
|
+
//#endregion
|
|
734
|
+
//#region src/services/parser/token/checkIsDigitCharacter.d.ts
|
|
735
|
+
export declare const checkIsDigitCharacter: (character: string) => boolean;
|
|
736
|
+
//#endregion
|
|
737
|
+
//#region src/services/parser/token/checkIsWordCharacter.d.ts
|
|
738
|
+
export declare const checkIsWordCharacter: (character: string) => boolean;
|
|
739
|
+
//#endregion
|
|
740
|
+
//#region src/services/parser/token/checkIsWordStartCharacter.d.ts
|
|
741
|
+
export declare const checkIsWordStartCharacter: (character: string) => boolean;
|
|
742
|
+
//#endregion
|
|
743
|
+
//#region src/services/parser/token/constants.d.ts
|
|
744
|
+
export declare const DELIMITERS_OF_THREE: ReadonlySet<string>;
|
|
745
|
+
export declare const DELIMITERS_OF_TWO: ReadonlySet<string>;
|
|
746
|
+
export declare const DELIMITERS_OF_ONE: ReadonlySet<string>;
|
|
747
|
+
export declare const FIRST_CHARACTERS_OF_THREE: ReadonlySet<string>;
|
|
748
|
+
export declare const FIRST_CHARACTERS_OF_TWO: ReadonlySet<string>;
|
|
749
|
+
export declare const NAMED_DELIMITERS: ReadonlySet<string>;
|
|
750
|
+
export declare const DECIMAL_MARK_OPERATOR_FOLLOWERS: ReadonlySet<string>;
|
|
751
|
+
export declare const WORD_START_REGEX: RegExp;
|
|
752
|
+
export declare const WORD_CHARACTER_REGEX: RegExp;
|
|
753
|
+
//#endregion
|
|
754
|
+
//#region src/services/parser/token/failExponent.d.ts
|
|
755
|
+
export declare const failExponent: (state: MathExpressionParserState, text: string) => void;
|
|
756
|
+
//#endregion
|
|
757
|
+
//#region src/services/parser/token/getMathExpressionCharacter.d.ts
|
|
758
|
+
export declare const getMathExpressionCharacter: (state: MathExpressionParserState, offset: number) => string;
|
|
759
|
+
//#endregion
|
|
760
|
+
//#region src/services/parser/token/readMathExpressionDelimiter.d.ts
|
|
761
|
+
export declare const readMathExpressionDelimiter: (state: MathExpressionParserState) => number;
|
|
762
|
+
//#endregion
|
|
763
|
+
//#region src/services/parser/token/readMathExpressionNumber.d.ts
|
|
764
|
+
export declare const readMathExpressionNumber: (state: MathExpressionParserState) => void;
|
|
765
|
+
//#endregion
|
|
766
|
+
//#region src/services/parser/token/readMathExpressionWord.d.ts
|
|
767
|
+
export declare const readMathExpressionWord: (state: MathExpressionParserState) => void;
|
|
768
|
+
//#endregion
|
|
769
|
+
//#region src/services/parser/token/readRadixNumber.d.ts
|
|
770
|
+
export declare const readRadixNumber: (state: MathExpressionParserState, prefix: string, baseDigits: RegExp) => void;
|
|
771
|
+
//#endregion
|
|
772
|
+
//#region src/services/parser/token/skipMathExpressionSpaces.d.ts
|
|
773
|
+
export declare const skipMathExpressionSpaces: (state: MathExpressionParserState) => void;
|
|
774
|
+
//#endregion
|
|
775
|
+
//#region src/services/parser/token/takeExponent.d.ts
|
|
776
|
+
export declare const takeExponent: (state: MathExpressionParserState, text: string) => string;
|
|
777
|
+
//#endregion
|
|
778
|
+
//#region src/services/parser/token/takeMathExpressionMatching.d.ts
|
|
779
|
+
export declare const takeMathExpressionMatching: (state: MathExpressionParserState, checkCharacter: (character: string) => boolean) => string;
|
|
780
|
+
//#endregion
|
|
781
|
+
//#region src/services/shared/MathExpressionConstantMap.d.ts
|
|
782
|
+
export declare const MathExpressionConstantMap: Record<string, number>;
|
|
783
|
+
//#endregion
|
|
784
|
+
//#region src/services/shared/checkIsMatching.d.ts
|
|
785
|
+
export declare const checkIsMatching: (signature: MathExpressionSignature, parameterTypes: MathExpressionParameterType[]) => boolean;
|
|
786
|
+
//#endregion
|
|
787
|
+
//#region src/services/shared/checkIsMatchingKind.d.ts
|
|
788
|
+
export declare const checkIsMatchingKind: (parameterType: MathExpressionParameterType | undefined, argumentType: MathExpressionParameterType) => boolean;
|
|
789
|
+
//#endregion
|
|
790
|
+
//#region src/services/shared/checkIsTruthy.d.ts
|
|
791
|
+
export declare const checkIsTruthy: (value: number) => boolean;
|
|
792
|
+
//#endregion
|
|
793
|
+
//#region src/services/shared/getMathExpressionChildren.d.ts
|
|
794
|
+
export declare const getMathExpressionChildren: (node: MathExpressionNode) => MathExpressionNode[];
|
|
795
|
+
//#endregion
|
|
796
|
+
//#region src/services/shared/getMathExpressionParameterType.d.ts
|
|
797
|
+
export declare const getMathExpressionParameterType: (node: MathExpressionNode) => MathExpressionParameterType;
|
|
798
|
+
//#endregion
|
|
799
|
+
//#region src/services/shared/getMathExpressionSignatures.d.ts
|
|
800
|
+
export declare const getMathExpressionSignatures: (name: string) => MathExpressionSignature[] | undefined;
|
|
801
|
+
//#endregion
|
|
802
|
+
//#region src/services/shared/getOwnValue.d.ts
|
|
803
|
+
export declare const getOwnValue: <T>(record: Readonly<Record<string, T>>, key: string) => T | undefined;
|
|
804
|
+
//#endregion
|
|
805
|
+
//#region src/services/shared/getParameterType.d.ts
|
|
806
|
+
export declare const getParameterType: (signature: MathExpressionSignature, index: number) => MathExpressionParameterType | undefined;
|
|
807
|
+
//#endregion
|
|
808
|
+
//#region src/services/shared/matchMathExpressionSignature.d.ts
|
|
809
|
+
export declare const matchMathExpressionSignature: (signatures: readonly MathExpressionSignature[], parameterTypes: MathExpressionParameterType[]) => MathExpressionSignature | undefined;
|
|
810
|
+
//#endregion
|
|
811
|
+
//#region src/services/shared/toNumber.d.ts
|
|
812
|
+
export declare const toNumber: (flag: boolean) => number;
|
|
813
|
+
//#endregion
|