UNPKG

16.2 kBJavaScriptView Raw
1function _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 * THIS FILE IS AUTO-GENERATED
5 * DON'T MAKE CHANGES HERE
6 */
7import { config } from './configReadonly';
8import { createNode, createArrayNode, createBlockNode, createConstantNode, createObjectNode, createParenthesisNode, createRelationalNode, createChainClass, createReviver, createConditionalNode, createOperatorNode, createRangeNode, createFunctionAssignmentNode, createChain, createAccessorNode, createIndexNode, createAssignmentNode, createSymbolNode, createFunctionNode, createParse, createEvaluate, createHelpClass, createCompile, createHelp, createSimplify, createRationalize, createDerivative, createParserClass, createParser, createApplyTransform, createFilterTransform, createMapTransform, createForEachTransform, createMaxTransform, createMinTransform, createSubsetTransform, createConcatTransform, createRangeTransform, createSumTransform, createIndexTransform, createColumnTransform, createRowTransform, createMeanTransform, createVarianceTransform, createStdTransform } from '../factoriesAny';
9import { ResultSet, Complex, Range, _false, _null, _true, BigNumber, Matrix, replacer, i, LN10, LOG10E, _NaN, pi, SQRT1_2 // eslint-disable-line camelcase
10, tau, efimovFactor, fineStructure, sackurTetrode, weakMixingAngle, Fraction, e, _Infinity, LOG2E, version, DenseMatrix, phi, typed, isInteger, isNumeric, isPositive, isNaN, equalScalar, number, boolean as _boolean, complex, splitUnit, unaryPlus, apply, cube, expm1, log10, multiplyScalar, sign, square, bitNot, arg, im, not, filter, forEach, map, erf, format, isPrime, acos, acot, acsc, asec, asin, atan, atanh, cosh, coth, csch, sech, sinh, tanh, combinations, pickRandom, randomInt, LN2, clone, hasNumericValue, typeOf, string, fraction, unaryMinus, addScalar, exp, log2, sqrt, conj, getMatrixDataType, mode, print, acosh, acsch, asinh, cos, csc, sin, combinationsWithRep, random, SQRT2, isNegative, SparseMatrix, matrix, cbrt, gcd, mod, nthRoot, xgcd, bitAnd, bitXor, or, concat, diag, identity, ones, reshape, size, subset, zeros, to, round, leftShift, rightLogShift, compare, compareText, smaller, larger, unequal, max, ImmutableDenseMatrix, FibonacciHeap, sparse, acoth, atan2, sec, add, dot, composition, isZero, abs, floor, multiply, dotMultiply, re, flatten, resize, squeeze, prod, pow, dotPow, rightArithShift, compareNatural, equalText, largerEq, partitionSelect, min, Spa, asech, tan, setSize, norm, quantileSeq, gamma, bignumber, lcm, bitOr, kron, transpose, numeric, and, smallerEq, sort, cot, trace, sum, factorial, permutations, ceil, subtract, cross, ctranspose, equal, Index, setCartesian, setDistinct, setIsSubset, setPowerset, index, fix, range, divideScalar, nthRoots, lsolve, deepEqual, setDifference, setMultiplicity, hypot, lup, slu, det, distance, stirlingS2, catalan, xor, row, dotDivide, Unit, createUnit, setSymDifference, qr, inv, expm, divide, mean, variance, multinomial, atomicMass, bohrMagneton, boltzmann, conductanceQuantum, deuteronMass, electronMass, faraday, firstRadiation, gravitationConstant, hartreeEnergy, klitzing, magneticConstant, molarMass, molarPlanckConstant, neutronMass, planckCharge, planckLength, planckTemperature, protonMass, reducedPlanckConstant, secondRadiation, stefanBoltzmann, vacuumImpedance, column, usolve, setIntersect, lusolve, eigs, intersect, std, bellNumbers, avogadro, classicalElectronRadius, electricConstant, fermiCoupling, gravity, loschmidt, molarMassC12, nuclearMagneton, planckMass, quantumOfCirculation, speedOfLight, wienDisplacement, log, unit, sqrtm, kldivergence, bohrRadius, elementaryCharge, inverseConductanceQuantum, molarVolume, planckTime, thomsonCrossSection, log1p, gasConstant, planckConstant, setUnion, median, magneticFluxQuantum, mad, rydberg, coulomb } from './pureFunctionsAny.generated';
11var math = {}; // NOT pure!
12
13var mathWithTransform = {}; // NOT pure!
14
15var classes = {}; // NOT pure!
16
17export var Node = createNode({
18 mathWithTransform: mathWithTransform
19});
20export var ArrayNode = createArrayNode({
21 Node: Node
22});
23export var BlockNode = createBlockNode({
24 Node: Node,
25 ResultSet: ResultSet
26});
27export var ConstantNode = createConstantNode({
28 Node: Node
29});
30export var ObjectNode = createObjectNode({
31 Node: Node
32});
33export var ParenthesisNode = createParenthesisNode({
34 Node: Node
35});
36export var RelationalNode = createRelationalNode({
37 Node: Node
38});
39export var Chain = createChainClass({
40 math: math
41});
42export var reviver = createReviver({
43 classes: classes
44});
45export var ConditionalNode = createConditionalNode({
46 Node: Node
47});
48export var OperatorNode = createOperatorNode({
49 Node: Node
50});
51export var RangeNode = createRangeNode({
52 Node: Node
53});
54export var FunctionAssignmentNode = createFunctionAssignmentNode({
55 Node: Node,
56 typed: typed
57});
58export var chain = createChain({
59 Chain: Chain,
60 typed: typed
61});
62export var AccessorNode = createAccessorNode({
63 Node: Node,
64 subset: subset
65});
66export var IndexNode = createIndexNode({
67 Node: Node,
68 Range: Range,
69 size: size
70});
71export var AssignmentNode = createAssignmentNode({
72 matrix: matrix,
73 Node: Node,
74 subset: subset
75});
76export var SymbolNode = createSymbolNode({
77 Unit: Unit,
78 Node: Node,
79 math: math
80});
81export var FunctionNode = createFunctionNode({
82 Node: Node,
83 SymbolNode: SymbolNode,
84 math: math
85});
86export var parse = createParse({
87 AccessorNode: AccessorNode,
88 ArrayNode: ArrayNode,
89 AssignmentNode: AssignmentNode,
90 BlockNode: BlockNode,
91 ConditionalNode: ConditionalNode,
92 ConstantNode: ConstantNode,
93 FunctionAssignmentNode: FunctionAssignmentNode,
94 FunctionNode: FunctionNode,
95 IndexNode: IndexNode,
96 ObjectNode: ObjectNode,
97 OperatorNode: OperatorNode,
98 ParenthesisNode: ParenthesisNode,
99 RangeNode: RangeNode,
100 RelationalNode: RelationalNode,
101 SymbolNode: SymbolNode,
102 config: config,
103 numeric: numeric,
104 typed: typed
105});
106export var evaluate = createEvaluate({
107 parse: parse,
108 typed: typed
109});
110export var Help = createHelpClass({
111 parse: parse
112});
113export var compile = createCompile({
114 parse: parse,
115 typed: typed
116});
117export var help = createHelp({
118 Help: Help,
119 mathWithTransform: mathWithTransform,
120 typed: typed
121});
122export var simplify = createSimplify({
123 bignumber: bignumber,
124 fraction: fraction,
125 ConstantNode: ConstantNode,
126 FunctionNode: FunctionNode,
127 OperatorNode: OperatorNode,
128 ParenthesisNode: ParenthesisNode,
129 SymbolNode: SymbolNode,
130 add: add,
131 config: config,
132 divide: divide,
133 equal: equal,
134 isZero: isZero,
135 mathWithTransform: mathWithTransform,
136 multiply: multiply,
137 parse: parse,
138 pow: pow,
139 subtract: subtract,
140 typed: typed
141});
142export var rationalize = createRationalize({
143 bignumber: bignumber,
144 fraction: fraction,
145 ConstantNode: ConstantNode,
146 FunctionNode: FunctionNode,
147 OperatorNode: OperatorNode,
148 ParenthesisNode: ParenthesisNode,
149 SymbolNode: SymbolNode,
150 add: add,
151 config: config,
152 divide: divide,
153 equal: equal,
154 isZero: isZero,
155 mathWithTransform: mathWithTransform,
156 multiply: multiply,
157 parse: parse,
158 pow: pow,
159 simplify: simplify,
160 subtract: subtract,
161 typed: typed
162});
163export var derivative = createDerivative({
164 ConstantNode: ConstantNode,
165 FunctionNode: FunctionNode,
166 OperatorNode: OperatorNode,
167 ParenthesisNode: ParenthesisNode,
168 SymbolNode: SymbolNode,
169 config: config,
170 equal: equal,
171 isZero: isZero,
172 numeric: numeric,
173 parse: parse,
174 simplify: simplify,
175 typed: typed
176});
177export var Parser = createParserClass({
178 parse: parse
179});
180export var parser = createParser({
181 Parser: Parser,
182 typed: typed
183});
184
185_extends(math, {
186 reviver: reviver,
187 "false": _false,
188 "null": _null,
189 "true": _true,
190 replacer: replacer,
191 i: i,
192 LN10: LN10,
193 LOG10E: LOG10E,
194 NaN: _NaN,
195 pi: pi,
196 SQRT1_2: SQRT1_2,
197 tau: tau,
198 efimovFactor: efimovFactor,
199 fineStructure: fineStructure,
200 sackurTetrode: sackurTetrode,
201 weakMixingAngle: weakMixingAngle,
202 e: e,
203 Infinity: _Infinity,
204 LOG2E: LOG2E,
205 'PI': pi,
206 version: version,
207 'E': e,
208 phi: phi,
209 typed: typed,
210 isInteger: isInteger,
211 isNumeric: isNumeric,
212 isPositive: isPositive,
213 isNaN: isNaN,
214 equalScalar: equalScalar,
215 number: number,
216 "boolean": _boolean,
217 complex: complex,
218 splitUnit: splitUnit,
219 unaryPlus: unaryPlus,
220 apply: apply,
221 cube: cube,
222 expm1: expm1,
223 log10: log10,
224 multiplyScalar: multiplyScalar,
225 sign: sign,
226 square: square,
227 bitNot: bitNot,
228 arg: arg,
229 im: im,
230 not: not,
231 filter: filter,
232 forEach: forEach,
233 map: map,
234 erf: erf,
235 format: format,
236 isPrime: isPrime,
237 acos: acos,
238 acot: acot,
239 acsc: acsc,
240 asec: asec,
241 asin: asin,
242 atan: atan,
243 atanh: atanh,
244 cosh: cosh,
245 coth: coth,
246 csch: csch,
247 sech: sech,
248 sinh: sinh,
249 tanh: tanh,
250 chain: chain,
251 combinations: combinations,
252 pickRandom: pickRandom,
253 randomInt: randomInt,
254 LN2: LN2,
255 clone: clone,
256 hasNumericValue: hasNumericValue,
257 typeOf: typeOf,
258 string: string,
259 fraction: fraction,
260 unaryMinus: unaryMinus,
261 addScalar: addScalar,
262 exp: exp,
263 log2: log2,
264 sqrt: sqrt,
265 conj: conj,
266 getMatrixDataType: getMatrixDataType,
267 mode: mode,
268 print: print,
269 acosh: acosh,
270 acsch: acsch,
271 asinh: asinh,
272 cos: cos,
273 csc: csc,
274 sin: sin,
275 combinationsWithRep: combinationsWithRep,
276 random: random,
277 SQRT2: SQRT2,
278 isNegative: isNegative,
279 matrix: matrix,
280 cbrt: cbrt,
281 gcd: gcd,
282 mod: mod,
283 nthRoot: nthRoot,
284 xgcd: xgcd,
285 bitAnd: bitAnd,
286 bitXor: bitXor,
287 or: or,
288 concat: concat,
289 diag: diag,
290 identity: identity,
291 ones: ones,
292 reshape: reshape,
293 size: size,
294 subset: subset,
295 zeros: zeros,
296 to: to,
297 round: round,
298 leftShift: leftShift,
299 rightLogShift: rightLogShift,
300 compare: compare,
301 compareText: compareText,
302 smaller: smaller,
303 larger: larger,
304 unequal: unequal,
305 max: max,
306 sparse: sparse,
307 acoth: acoth,
308 atan2: atan2,
309 sec: sec,
310 add: add,
311 dot: dot,
312 composition: composition,
313 isZero: isZero,
314 abs: abs,
315 floor: floor,
316 multiply: multiply,
317 dotMultiply: dotMultiply,
318 re: re,
319 flatten: flatten,
320 resize: resize,
321 squeeze: squeeze,
322 prod: prod,
323 pow: pow,
324 dotPow: dotPow,
325 rightArithShift: rightArithShift,
326 compareNatural: compareNatural,
327 equalText: equalText,
328 largerEq: largerEq,
329 partitionSelect: partitionSelect,
330 min: min,
331 asech: asech,
332 tan: tan,
333 setSize: setSize,
334 norm: norm,
335 quantileSeq: quantileSeq,
336 gamma: gamma,
337 bignumber: bignumber,
338 lcm: lcm,
339 bitOr: bitOr,
340 kron: kron,
341 transpose: transpose,
342 numeric: numeric,
343 and: and,
344 smallerEq: smallerEq,
345 sort: sort,
346 cot: cot,
347 trace: trace,
348 sum: sum,
349 factorial: factorial,
350 permutations: permutations,
351 ceil: ceil,
352 subtract: subtract,
353 cross: cross,
354 ctranspose: ctranspose,
355 equal: equal,
356 setCartesian: setCartesian,
357 setDistinct: setDistinct,
358 setIsSubset: setIsSubset,
359 setPowerset: setPowerset,
360 index: index,
361 fix: fix,
362 range: range,
363 divideScalar: divideScalar,
364 nthRoots: nthRoots,
365 lsolve: lsolve,
366 deepEqual: deepEqual,
367 setDifference: setDifference,
368 setMultiplicity: setMultiplicity,
369 hypot: hypot,
370 lup: lup,
371 slu: slu,
372 det: det,
373 distance: distance,
374 stirlingS2: stirlingS2,
375 catalan: catalan,
376 xor: xor,
377 row: row,
378 dotDivide: dotDivide,
379 createUnit: createUnit,
380 setSymDifference: setSymDifference,
381 qr: qr,
382 inv: inv,
383 expm: expm,
384 divide: divide,
385 mean: mean,
386 variance: variance,
387 multinomial: multinomial,
388 atomicMass: atomicMass,
389 bohrMagneton: bohrMagneton,
390 boltzmann: boltzmann,
391 conductanceQuantum: conductanceQuantum,
392 deuteronMass: deuteronMass,
393 electronMass: electronMass,
394 faraday: faraday,
395 firstRadiation: firstRadiation,
396 gravitationConstant: gravitationConstant,
397 hartreeEnergy: hartreeEnergy,
398 klitzing: klitzing,
399 magneticConstant: magneticConstant,
400 molarMass: molarMass,
401 molarPlanckConstant: molarPlanckConstant,
402 neutronMass: neutronMass,
403 planckCharge: planckCharge,
404 planckLength: planckLength,
405 planckTemperature: planckTemperature,
406 protonMass: protonMass,
407 reducedPlanckConstant: reducedPlanckConstant,
408 secondRadiation: secondRadiation,
409 stefanBoltzmann: stefanBoltzmann,
410 vacuumImpedance: vacuumImpedance,
411 column: column,
412 usolve: usolve,
413 setIntersect: setIntersect,
414 lusolve: lusolve,
415 eigs: eigs,
416 intersect: intersect,
417 std: std,
418 bellNumbers: bellNumbers,
419 avogadro: avogadro,
420 classicalElectronRadius: classicalElectronRadius,
421 electricConstant: electricConstant,
422 fermiCoupling: fermiCoupling,
423 gravity: gravity,
424 loschmidt: loschmidt,
425 molarMassC12: molarMassC12,
426 nuclearMagneton: nuclearMagneton,
427 planckMass: planckMass,
428 quantumOfCirculation: quantumOfCirculation,
429 speedOfLight: speedOfLight,
430 wienDisplacement: wienDisplacement,
431 log: log,
432 unit: unit,
433 parse: parse,
434 evaluate: evaluate,
435 sqrtm: sqrtm,
436 kldivergence: kldivergence,
437 bohrRadius: bohrRadius,
438 elementaryCharge: elementaryCharge,
439 inverseConductanceQuantum: inverseConductanceQuantum,
440 molarVolume: molarVolume,
441 planckTime: planckTime,
442 thomsonCrossSection: thomsonCrossSection,
443 log1p: log1p,
444 compile: compile,
445 help: help,
446 simplify: simplify,
447 rationalize: rationalize,
448 gasConstant: gasConstant,
449 planckConstant: planckConstant,
450 setUnion: setUnion,
451 median: median,
452 derivative: derivative,
453 magneticFluxQuantum: magneticFluxQuantum,
454 mad: mad,
455 rydberg: rydberg,
456 parser: parser,
457 coulomb: coulomb,
458 config: config
459});
460
461_extends(mathWithTransform, math, {
462 apply: createApplyTransform({
463 isInteger: isInteger,
464 typed: typed
465 }),
466 filter: createFilterTransform({
467 typed: typed
468 }),
469 map: createMapTransform({
470 typed: typed
471 }),
472 forEach: createForEachTransform({
473 typed: typed
474 }),
475 max: createMaxTransform({
476 larger: larger,
477 typed: typed
478 }),
479 min: createMinTransform({
480 smaller: smaller,
481 typed: typed
482 }),
483 subset: createSubsetTransform({
484 matrix: matrix,
485 typed: typed
486 }),
487 concat: createConcatTransform({
488 isInteger: isInteger,
489 matrix: matrix,
490 typed: typed
491 }),
492 range: createRangeTransform({
493 bignumber: bignumber,
494 matrix: matrix,
495 config: config,
496 larger: larger,
497 largerEq: largerEq,
498 smaller: smaller,
499 smallerEq: smallerEq,
500 typed: typed
501 }),
502 sum: createSumTransform({
503 bignumber: bignumber,
504 fraction: fraction,
505 add: add,
506 config: config,
507 typed: typed
508 }),
509 index: createIndexTransform({
510 Index: Index
511 }),
512 column: createColumnTransform({
513 Index: Index,
514 matrix: matrix,
515 range: range,
516 typed: typed
517 }),
518 row: createRowTransform({
519 Index: Index,
520 matrix: matrix,
521 range: range,
522 typed: typed
523 }),
524 mean: createMeanTransform({
525 add: add,
526 divide: divide,
527 typed: typed
528 }),
529 variance: createVarianceTransform({
530 add: add,
531 apply: apply,
532 divide: divide,
533 isNaN: isNaN,
534 multiply: multiply,
535 subtract: subtract,
536 typed: typed
537 }),
538 std: createStdTransform({
539 sqrt: sqrt,
540 typed: typed,
541 variance: variance
542 })
543});
544
545_extends(classes, {
546 ResultSet: ResultSet,
547 Complex: Complex,
548 Range: Range,
549 Node: Node,
550 ArrayNode: ArrayNode,
551 BlockNode: BlockNode,
552 ConstantNode: ConstantNode,
553 ObjectNode: ObjectNode,
554 ParenthesisNode: ParenthesisNode,
555 RelationalNode: RelationalNode,
556 Chain: Chain,
557 BigNumber: BigNumber,
558 Matrix: Matrix,
559 ConditionalNode: ConditionalNode,
560 OperatorNode: OperatorNode,
561 Fraction: Fraction,
562 RangeNode: RangeNode,
563 DenseMatrix: DenseMatrix,
564 FunctionAssignmentNode: FunctionAssignmentNode,
565 SparseMatrix: SparseMatrix,
566 ImmutableDenseMatrix: ImmutableDenseMatrix,
567 FibonacciHeap: FibonacciHeap,
568 AccessorNode: AccessorNode,
569 IndexNode: IndexNode,
570 Spa: Spa,
571 AssignmentNode: AssignmentNode,
572 Index: Index,
573 Unit: Unit,
574 SymbolNode: SymbolNode,
575 FunctionNode: FunctionNode,
576 Help: Help,
577 Parser: Parser
578});
579
580Chain.createProxy(math);
581export { embeddedDocs as docs } from '../expression/embeddedDocs/embeddedDocs';
\No newline at end of file