1 | function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
|
2 |
|
3 |
|
4 |
|
5 |
|
6 |
|
7 | import { config } from './configReadonly';
|
8 | import { createChainClass, createChain, createNode, createArrayNode, createConditionalNode, createFunctionAssignmentNode, createObjectNode, createParenthesisNode, createRelationalNode, createReviver, createBlockNode, createOperatorNode, createSymbolNode, createAccessorNode, createConstantNode, createRangeNode, createAssignmentNode, createFunctionNode, createIndexNode, createParse, createEvaluate, createHelpClass, createSimplify, createRationalize, createCompile, createHelp, createParserClass, createDerivative, createParser, createFilterTransform, createMapTransform, createMinTransform, createForEachTransform, createSubsetTransform, createApplyTransform, createRangeTransform, createSumTransform, createMaxTransform, createMeanTransform, createStdTransform, createVarianceTransform } from '../factoriesNumber';
|
9 | import { typed, Range, nthRoot, e, _false, LN10, LOG10E, _NaN, phi, SQRT1_2
|
10 | , tau, version, string, filter, map, combinationsWithRep, pickRandom, randomInt, compare, compareText, smaller, larger, erf, max, format, clone, typeOf, unaryMinus, abs, cbrt, cube, expm1, floor, lcm, log2, multiplyScalar, sign, square, xgcd, pow, log1p, norm, bitAnd, bitOr, leftShift, rightLogShift, not, xor, matrix, combinations, acos, acot, acsc, asec, asin, atan, atanh, cosh, coth, csch, sech, sinh, tanh, isNegative, isZero, ResultSet, round, LN2, _null, SQRT2, number, forEach, size, random, compareNatural, equalText, largerEq, min, print, isNumeric, isPrime, replacer, addScalar, exp, gcd, mod, sqrt, divideScalar, add, bitNot, rightArithShift, or, subset, acosh, acsch, asinh, cos, csc, sin, isInteger, isNaN, catalan, _Infinity, pi, _true, apply, partitionSelect, equalScalar, smallerEq, unequal, sum, hasNumericValue, unaryPlus, fix, multiply, log, bitXor, index, acoth, atan2, sec, isPositive, hypot, composition, range, equal, mode, quantileSeq, numeric, log10, divide, gamma, cot, LOG2E, factorial, permutations, prod, median, ceil, and, tan, boolean as _boolean, multinomial, mean, subtract, deepEqual, variance, asech, stirlingS2, std, bellNumbers, mad } from './pureFunctionsNumber.generated';
|
11 | var math = {};
|
12 |
|
13 | var mathWithTransform = {};
|
14 |
|
15 | var classes = {};
|
16 |
|
17 | export var Chain = createChainClass({
|
18 | math: math
|
19 | });
|
20 | export var chain = createChain({
|
21 | Chain: Chain,
|
22 | typed: typed
|
23 | });
|
24 | export var Node = createNode({
|
25 | mathWithTransform: mathWithTransform
|
26 | });
|
27 | export var ArrayNode = createArrayNode({
|
28 | Node: Node
|
29 | });
|
30 | export var ConditionalNode = createConditionalNode({
|
31 | Node: Node
|
32 | });
|
33 | export var FunctionAssignmentNode = createFunctionAssignmentNode({
|
34 | Node: Node,
|
35 | typed: typed
|
36 | });
|
37 | export var ObjectNode = createObjectNode({
|
38 | Node: Node
|
39 | });
|
40 | export var ParenthesisNode = createParenthesisNode({
|
41 | Node: Node
|
42 | });
|
43 | export var RelationalNode = createRelationalNode({
|
44 | Node: Node
|
45 | });
|
46 | export var reviver = createReviver({
|
47 | classes: classes
|
48 | });
|
49 | export var BlockNode = createBlockNode({
|
50 | Node: Node,
|
51 | ResultSet: ResultSet
|
52 | });
|
53 | export var OperatorNode = createOperatorNode({
|
54 | Node: Node
|
55 | });
|
56 | export var SymbolNode = createSymbolNode({
|
57 | Node: Node,
|
58 | math: math
|
59 | });
|
60 | export var AccessorNode = createAccessorNode({
|
61 | Node: Node,
|
62 | subset: subset
|
63 | });
|
64 | export var ConstantNode = createConstantNode({
|
65 | Node: Node
|
66 | });
|
67 | export var RangeNode = createRangeNode({
|
68 | Node: Node
|
69 | });
|
70 | export var AssignmentNode = createAssignmentNode({
|
71 | matrix: matrix,
|
72 | Node: Node,
|
73 | subset: subset
|
74 | });
|
75 | export var FunctionNode = createFunctionNode({
|
76 | Node: Node,
|
77 | SymbolNode: SymbolNode,
|
78 | math: math
|
79 | });
|
80 | export var IndexNode = createIndexNode({
|
81 | Node: Node,
|
82 | Range: Range,
|
83 | size: size
|
84 | });
|
85 | export var parse = createParse({
|
86 | AccessorNode: AccessorNode,
|
87 | ArrayNode: ArrayNode,
|
88 | AssignmentNode: AssignmentNode,
|
89 | BlockNode: BlockNode,
|
90 | ConditionalNode: ConditionalNode,
|
91 | ConstantNode: ConstantNode,
|
92 | FunctionAssignmentNode: FunctionAssignmentNode,
|
93 | FunctionNode: FunctionNode,
|
94 | IndexNode: IndexNode,
|
95 | ObjectNode: ObjectNode,
|
96 | OperatorNode: OperatorNode,
|
97 | ParenthesisNode: ParenthesisNode,
|
98 | RangeNode: RangeNode,
|
99 | RelationalNode: RelationalNode,
|
100 | SymbolNode: SymbolNode,
|
101 | config: config,
|
102 | numeric: numeric,
|
103 | typed: typed
|
104 | });
|
105 | export var evaluate = createEvaluate({
|
106 | parse: parse,
|
107 | typed: typed
|
108 | });
|
109 | export var Help = createHelpClass({
|
110 | parse: parse
|
111 | });
|
112 | export var simplify = createSimplify({
|
113 | ConstantNode: ConstantNode,
|
114 | FunctionNode: FunctionNode,
|
115 | OperatorNode: OperatorNode,
|
116 | ParenthesisNode: ParenthesisNode,
|
117 | SymbolNode: SymbolNode,
|
118 | add: add,
|
119 | config: config,
|
120 | divide: divide,
|
121 | equal: equal,
|
122 | isZero: isZero,
|
123 | mathWithTransform: mathWithTransform,
|
124 | multiply: multiply,
|
125 | parse: parse,
|
126 | pow: pow,
|
127 | subtract: subtract,
|
128 | typed: typed
|
129 | });
|
130 | export var rationalize = createRationalize({
|
131 | ConstantNode: ConstantNode,
|
132 | FunctionNode: FunctionNode,
|
133 | OperatorNode: OperatorNode,
|
134 | ParenthesisNode: ParenthesisNode,
|
135 | SymbolNode: SymbolNode,
|
136 | add: add,
|
137 | config: config,
|
138 | divide: divide,
|
139 | equal: equal,
|
140 | isZero: isZero,
|
141 | mathWithTransform: mathWithTransform,
|
142 | multiply: multiply,
|
143 | parse: parse,
|
144 | pow: pow,
|
145 | simplify: simplify,
|
146 | subtract: subtract,
|
147 | typed: typed
|
148 | });
|
149 | export var compile = createCompile({
|
150 | parse: parse,
|
151 | typed: typed
|
152 | });
|
153 | export var help = createHelp({
|
154 | Help: Help,
|
155 | mathWithTransform: mathWithTransform,
|
156 | typed: typed
|
157 | });
|
158 | export var Parser = createParserClass({
|
159 | parse: parse
|
160 | });
|
161 | export var derivative = createDerivative({
|
162 | ConstantNode: ConstantNode,
|
163 | FunctionNode: FunctionNode,
|
164 | OperatorNode: OperatorNode,
|
165 | ParenthesisNode: ParenthesisNode,
|
166 | SymbolNode: SymbolNode,
|
167 | config: config,
|
168 | equal: equal,
|
169 | isZero: isZero,
|
170 | numeric: numeric,
|
171 | parse: parse,
|
172 | simplify: simplify,
|
173 | typed: typed
|
174 | });
|
175 | export var parser = createParser({
|
176 | Parser: Parser,
|
177 | typed: typed
|
178 | });
|
179 |
|
180 | _extends(math, {
|
181 | typed: typed,
|
182 | chain: chain,
|
183 | nthRoot: nthRoot,
|
184 | e: e,
|
185 | "false": _false,
|
186 | LN10: LN10,
|
187 | LOG10E: LOG10E,
|
188 | NaN: _NaN,
|
189 | phi: phi,
|
190 | SQRT1_2: SQRT1_2,
|
191 | tau: tau,
|
192 | version: version,
|
193 | string: string,
|
194 | filter: filter,
|
195 | map: map,
|
196 | combinationsWithRep: combinationsWithRep,
|
197 | pickRandom: pickRandom,
|
198 | randomInt: randomInt,
|
199 | compare: compare,
|
200 | compareText: compareText,
|
201 | smaller: smaller,
|
202 | larger: larger,
|
203 | erf: erf,
|
204 | max: max,
|
205 | format: format,
|
206 | clone: clone,
|
207 | typeOf: typeOf,
|
208 | reviver: reviver,
|
209 | unaryMinus: unaryMinus,
|
210 | abs: abs,
|
211 | cbrt: cbrt,
|
212 | cube: cube,
|
213 | expm1: expm1,
|
214 | floor: floor,
|
215 | lcm: lcm,
|
216 | log2: log2,
|
217 | multiplyScalar: multiplyScalar,
|
218 | sign: sign,
|
219 | square: square,
|
220 | xgcd: xgcd,
|
221 | pow: pow,
|
222 | log1p: log1p,
|
223 | norm: norm,
|
224 | bitAnd: bitAnd,
|
225 | bitOr: bitOr,
|
226 | leftShift: leftShift,
|
227 | rightLogShift: rightLogShift,
|
228 | not: not,
|
229 | xor: xor,
|
230 | matrix: matrix,
|
231 | combinations: combinations,
|
232 | acos: acos,
|
233 | acot: acot,
|
234 | acsc: acsc,
|
235 | asec: asec,
|
236 | asin: asin,
|
237 | atan: atan,
|
238 | atanh: atanh,
|
239 | cosh: cosh,
|
240 | coth: coth,
|
241 | csch: csch,
|
242 | sech: sech,
|
243 | sinh: sinh,
|
244 | tanh: tanh,
|
245 | isNegative: isNegative,
|
246 | isZero: isZero,
|
247 | round: round,
|
248 | 'E': e,
|
249 | LN2: LN2,
|
250 | "null": _null,
|
251 | SQRT2: SQRT2,
|
252 | number: number,
|
253 | forEach: forEach,
|
254 | size: size,
|
255 | random: random,
|
256 | compareNatural: compareNatural,
|
257 | equalText: equalText,
|
258 | largerEq: largerEq,
|
259 | min: min,
|
260 | print: print,
|
261 | isNumeric: isNumeric,
|
262 | isPrime: isPrime,
|
263 | replacer: replacer,
|
264 | addScalar: addScalar,
|
265 | exp: exp,
|
266 | gcd: gcd,
|
267 | mod: mod,
|
268 | sqrt: sqrt,
|
269 | divideScalar: divideScalar,
|
270 | add: add,
|
271 | bitNot: bitNot,
|
272 | rightArithShift: rightArithShift,
|
273 | or: or,
|
274 | subset: subset,
|
275 | acosh: acosh,
|
276 | acsch: acsch,
|
277 | asinh: asinh,
|
278 | cos: cos,
|
279 | csc: csc,
|
280 | sin: sin,
|
281 | isInteger: isInteger,
|
282 | isNaN: isNaN,
|
283 | catalan: catalan,
|
284 | Infinity: _Infinity,
|
285 | pi: pi,
|
286 | "true": _true,
|
287 | apply: apply,
|
288 | partitionSelect: partitionSelect,
|
289 | equalScalar: equalScalar,
|
290 | smallerEq: smallerEq,
|
291 | unequal: unequal,
|
292 | sum: sum,
|
293 | hasNumericValue: hasNumericValue,
|
294 | unaryPlus: unaryPlus,
|
295 | fix: fix,
|
296 | multiply: multiply,
|
297 | log: log,
|
298 | bitXor: bitXor,
|
299 | index: index,
|
300 | acoth: acoth,
|
301 | atan2: atan2,
|
302 | sec: sec,
|
303 | isPositive: isPositive,
|
304 | hypot: hypot,
|
305 | composition: composition,
|
306 | 'PI': pi,
|
307 | range: range,
|
308 | equal: equal,
|
309 | mode: mode,
|
310 | quantileSeq: quantileSeq,
|
311 | numeric: numeric,
|
312 | log10: log10,
|
313 | divide: divide,
|
314 | gamma: gamma,
|
315 | cot: cot,
|
316 | LOG2E: LOG2E,
|
317 | factorial: factorial,
|
318 | permutations: permutations,
|
319 | prod: prod,
|
320 | median: median,
|
321 | ceil: ceil,
|
322 | and: and,
|
323 | tan: tan,
|
324 | "boolean": _boolean,
|
325 | parse: parse,
|
326 | evaluate: evaluate,
|
327 | multinomial: multinomial,
|
328 | mean: mean,
|
329 | subtract: subtract,
|
330 | simplify: simplify,
|
331 | rationalize: rationalize,
|
332 | compile: compile,
|
333 | deepEqual: deepEqual,
|
334 | variance: variance,
|
335 | asech: asech,
|
336 | help: help,
|
337 | stirlingS2: stirlingS2,
|
338 | std: std,
|
339 | derivative: derivative,
|
340 | parser: parser,
|
341 | bellNumbers: bellNumbers,
|
342 | mad: mad,
|
343 | config: config
|
344 | });
|
345 |
|
346 | _extends(mathWithTransform, math, {
|
347 | filter: createFilterTransform({
|
348 | typed: typed
|
349 | }),
|
350 | map: createMapTransform({
|
351 | typed: typed
|
352 | }),
|
353 | min: createMinTransform({
|
354 | smaller: smaller,
|
355 | typed: typed
|
356 | }),
|
357 | forEach: createForEachTransform({
|
358 | typed: typed
|
359 | }),
|
360 | subset: createSubsetTransform({
|
361 | matrix: matrix,
|
362 | typed: typed
|
363 | }),
|
364 | apply: createApplyTransform({
|
365 | isInteger: isInteger,
|
366 | typed: typed
|
367 | }),
|
368 | range: createRangeTransform({
|
369 | matrix: matrix,
|
370 | config: config,
|
371 | larger: larger,
|
372 | largerEq: largerEq,
|
373 | smaller: smaller,
|
374 | smallerEq: smallerEq,
|
375 | typed: typed
|
376 | }),
|
377 | sum: createSumTransform({
|
378 | add: add,
|
379 | config: config,
|
380 | typed: typed
|
381 | }),
|
382 | max: createMaxTransform({
|
383 | larger: larger,
|
384 | typed: typed
|
385 | }),
|
386 | mean: createMeanTransform({
|
387 | add: add,
|
388 | divide: divide,
|
389 | typed: typed
|
390 | }),
|
391 | std: createStdTransform({
|
392 | sqrt: sqrt,
|
393 | typed: typed,
|
394 | variance: variance
|
395 | }),
|
396 | variance: createVarianceTransform({
|
397 | add: add,
|
398 | apply: apply,
|
399 | divide: divide,
|
400 | isNaN: isNaN,
|
401 | multiply: multiply,
|
402 | subtract: subtract,
|
403 | typed: typed
|
404 | })
|
405 | });
|
406 |
|
407 | _extends(classes, {
|
408 | Range: Range,
|
409 | Chain: Chain,
|
410 | Node: Node,
|
411 | ArrayNode: ArrayNode,
|
412 | ConditionalNode: ConditionalNode,
|
413 | FunctionAssignmentNode: FunctionAssignmentNode,
|
414 | ObjectNode: ObjectNode,
|
415 | ParenthesisNode: ParenthesisNode,
|
416 | RelationalNode: RelationalNode,
|
417 | ResultSet: ResultSet,
|
418 | BlockNode: BlockNode,
|
419 | OperatorNode: OperatorNode,
|
420 | SymbolNode: SymbolNode,
|
421 | AccessorNode: AccessorNode,
|
422 | ConstantNode: ConstantNode,
|
423 | RangeNode: RangeNode,
|
424 | AssignmentNode: AssignmentNode,
|
425 | FunctionNode: FunctionNode,
|
426 | IndexNode: IndexNode,
|
427 | Help: Help,
|
428 | Parser: Parser
|
429 | });
|
430 |
|
431 | Chain.createProxy(math);
|
432 | export { embeddedDocs as docs } from '../expression/embeddedDocs/embeddedDocs'; |
\ | No newline at end of file |