mathjs 10.4.0 → 10.4.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/HISTORY.md +17 -0
- package/lib/browser/math.js +3 -3
- package/lib/browser/math.js.map +1 -1
- package/lib/cjs/entry/pureFunctionsAny.generated.js +2 -2
- package/lib/cjs/entry/pureFunctionsNumber.generated.js +1 -1
- package/lib/cjs/expression/parse.js +12 -8
- package/lib/cjs/factoriesNumber.js +1 -1
- package/lib/cjs/function/matrix/eigs/complexEigs.js +31 -22
- package/lib/cjs/header.js +2 -2
- package/lib/cjs/version.js +1 -1
- package/lib/esm/expression/parse.js +12 -8
- package/lib/esm/function/matrix/eigs/complexEigs.js +28 -19
- package/lib/esm/version.js +1 -1
- package/package.json +14 -10
- package/types/index.d.ts +106 -20
- package/types/index.ts +274 -57
- package/types/tsconfig.json +2 -1
package/types/index.ts
CHANGED
@@ -8,6 +8,12 @@ import {
|
|
8
8
|
divideDependencies,
|
9
9
|
formatDependencies,
|
10
10
|
} from 'mathjs';
|
11
|
+
import * as assert from 'assert';
|
12
|
+
import { expectTypeOf } from 'expect-type'
|
13
|
+
|
14
|
+
// This file serves a dual purpose:
|
15
|
+
// 1) examples of how to use math.js in TypeScript
|
16
|
+
// 2) tests for the TypeScript declarations provided by math.js
|
11
17
|
|
12
18
|
/*
|
13
19
|
Basic usage examples
|
@@ -25,17 +31,45 @@ Basic usage examples
|
|
25
31
|
const angle = 0.2;
|
26
32
|
math.add(math.pow(math.sin(angle), 2), math.pow(math.cos(angle), 2));
|
27
33
|
|
34
|
+
// std and variance check
|
35
|
+
math.std(1, 2, 3)
|
36
|
+
math.std([1, 2, 3])
|
37
|
+
math.std([1, 2, 3], "biased")
|
38
|
+
math.std([1,2, 3], 0, "biased")
|
39
|
+
math.std([[1,2,3], [4,5,6]], 1, "unbiased")
|
40
|
+
math.std([[1,2,3], [4,5,6]], 1, "uncorrected")
|
41
|
+
math.variance(1, 2, 3)
|
42
|
+
math.variance([1, 2, 3])
|
43
|
+
math.variance([1, 2, 3], "biased")
|
44
|
+
math.variance([1,2, 3], 0, "biased")
|
45
|
+
math.variance([[1,2,3], [4,5,6]], 1, "unbiased")
|
46
|
+
math.variance([[1,2,3], [4,5,6]], 1, "uncorrected")
|
47
|
+
|
48
|
+
// std and variance on chain
|
49
|
+
math.chain([1, 2, 3]).std("unbiased")
|
50
|
+
math.chain([[1, 2, 3], [4, 5, 6]]).std(0, "biased").std(0, "uncorrected")
|
51
|
+
math.chain([[1, 2, 3], [4, 5, 6]]).std(0, "biased").std(0, "uncorrected")
|
52
|
+
math.chain([1, 2, 3]).std("unbiased")
|
53
|
+
math.chain([[1, 2, 3], [4, 5, 6]]).variance(0, "biased")
|
54
|
+
math.chain([[1, 2, 3], [4, 5, 6]]).variance(1, "uncorrected").variance("unbiased")
|
55
|
+
|
56
|
+
|
28
57
|
// expressions
|
29
58
|
math.evaluate('1.2 * (2 + 4.5)');
|
30
59
|
|
31
60
|
// chained operations
|
32
|
-
const a = math.chain(3).add(4).multiply(2).done();
|
61
|
+
const a = math.chain(3).add(4).multiply(2).done();
|
62
|
+
assert.strictEqual(a, 14);
|
33
63
|
|
34
64
|
// mixed use of different data types in functions
|
35
|
-
math.add(4, [5, 6]); // number + Array
|
36
|
-
math.multiply(math.unit('5 mm'), 3); // Unit * number
|
37
|
-
math.subtract([2, 3, 4], 5)
|
38
|
-
math.add(math.matrix([2, 3]), [4, 5]); // Matrix + Array
|
65
|
+
assert.deepStrictEqual(math.add(4, [5, 6]), [9, 10]); // number + Array
|
66
|
+
assert.deepStrictEqual(math.multiply(math.unit('5 mm'), 3), math.unit('15 mm')); // Unit * number
|
67
|
+
assert.deepStrictEqual(math.subtract([2, 3, 4], 5), [-3, -2, -1]); // Array - number
|
68
|
+
assert.deepStrictEqual(math.add(math.matrix([2, 3]), [4, 5]), math.matrix([6, 8])); // Matrix + Array
|
69
|
+
|
70
|
+
// narrowed type inference
|
71
|
+
const b: math.Matrix = math.add(math.matrix([2]), math.matrix([3]));
|
72
|
+
const c: math.Matrix = math.subtract(math.matrix([4]), math.matrix([5]));
|
39
73
|
}
|
40
74
|
|
41
75
|
/*
|
@@ -49,8 +83,8 @@ Bignumbers examples
|
|
49
83
|
});
|
50
84
|
|
51
85
|
{
|
52
|
-
math.add(math.bignumber(0.1), math.bignumber(0.2))
|
53
|
-
math.divide(math.bignumber(0.3), math.bignumber(0.2))
|
86
|
+
assert.deepStrictEqual(math.add(math.bignumber(0.1), math.bignumber(0.2)), math.bignumber(0.3));
|
87
|
+
assert.deepStrictEqual(math.divide(math.bignumber(0.3), math.bignumber(0.2)), math.bignumber(1.5));
|
54
88
|
}
|
55
89
|
}
|
56
90
|
|
@@ -59,14 +93,16 @@ Chaining examples
|
|
59
93
|
*/
|
60
94
|
{
|
61
95
|
const math = create(all, {});
|
62
|
-
const a = math.chain(3).add(4).multiply(2).done();
|
96
|
+
const a = math.chain(3).add(4).multiply(2).done();
|
97
|
+
assert.strictEqual(a, 14);
|
63
98
|
|
64
99
|
// Another example, calculate square(sin(pi / 4))
|
65
100
|
const b = math.chain(math.pi).divide(4).sin().square().done();
|
66
101
|
|
67
102
|
// toString will return a string representation of the chain's value
|
68
103
|
const chain = math.chain(2).divide(3);
|
69
|
-
const str: string = chain.toString();
|
104
|
+
const str: string = chain.toString();
|
105
|
+
assert.strictEqual(str, "0.6666666666666666");
|
70
106
|
|
71
107
|
chain.valueOf();
|
72
108
|
|
@@ -75,17 +111,21 @@ Chaining examples
|
|
75
111
|
[1, 2],
|
76
112
|
[3, 4],
|
77
113
|
];
|
78
|
-
const v = math.chain(array).subset(math.index(1, 0)).done();
|
114
|
+
const v = math.chain(array).subset(math.index(1, 0)).done();
|
115
|
+
assert.strictEqual(v, 3);
|
79
116
|
|
80
117
|
const m = math.chain(array).subset(math.index(0, 0), 8).multiply(3).done();
|
81
118
|
|
82
119
|
// filtering
|
83
|
-
|
84
|
-
|
85
|
-
|
86
|
-
|
87
|
-
|
88
|
-
|
120
|
+
assert.deepStrictEqual(
|
121
|
+
math
|
122
|
+
.chain([-1, 0, 1.1, 2, 3, 1000])
|
123
|
+
.filter(math.isPositive)
|
124
|
+
.filter(math.isInteger)
|
125
|
+
.filter((n) => n !== 1000)
|
126
|
+
.done(),
|
127
|
+
[2, 3]
|
128
|
+
);
|
89
129
|
}
|
90
130
|
|
91
131
|
/*
|
@@ -164,13 +204,16 @@ Expressions examples
|
|
164
204
|
// get content of a parenthesis node
|
165
205
|
{
|
166
206
|
const node = math.parse('(1)');
|
207
|
+
if (node.type !== 'ParenthesisNode') {
|
208
|
+
throw Error(`expected ParenthesisNode, got ${node.type}`);
|
209
|
+
}
|
167
210
|
const innerNode = node.content;
|
168
211
|
}
|
169
212
|
|
170
213
|
// scope can contain both variables and functions
|
171
214
|
{
|
172
215
|
const scope = { hello: (name: string) => `hello, ${name}!` };
|
173
|
-
math.evaluate('hello("hero")', scope)
|
216
|
+
assert.strictEqual(math.evaluate('hello("hero")', scope), "hello, hero!");
|
174
217
|
}
|
175
218
|
|
176
219
|
// define a function as an expression
|
@@ -203,10 +246,10 @@ Expressions examples
|
|
203
246
|
|
204
247
|
// get and set variables and functions
|
205
248
|
{
|
206
|
-
parser.evaluate('x = 7 / 2')
|
207
|
-
parser.evaluate('x + 3')
|
249
|
+
assert.strictEqual(parser.evaluate('x = 7 / 2'), 3.5);
|
250
|
+
assert.strictEqual(parser.evaluate('x + 3'), 6.5);
|
208
251
|
parser.evaluate('f(x, y) = x^y'); // f(x, y)
|
209
|
-
parser.evaluate('f(2, 3)')
|
252
|
+
assert.strictEqual(parser.evaluate('f(2, 3)'), 8);
|
210
253
|
|
211
254
|
const x = parser.get('x');
|
212
255
|
const f = parser.get('f');
|
@@ -277,7 +320,7 @@ Matrices examples
|
|
277
320
|
b.subset(math.index(1, [0, 1]), [[7, 8]]);
|
278
321
|
const c = math.multiply(a, b);
|
279
322
|
const f: math.Matrix = math.matrix([1, 0]);
|
280
|
-
const d: math.Matrix = f.subset(math.index(1
|
323
|
+
const d: math.Matrix = f.subset(math.index(1));
|
281
324
|
}
|
282
325
|
|
283
326
|
// get a sub matrix
|
@@ -313,23 +356,34 @@ Matrices examples
|
|
313
356
|
|
314
357
|
// map matrix
|
315
358
|
{
|
316
|
-
|
317
|
-
|
318
|
-
|
359
|
+
assert.deepStrictEqual(
|
360
|
+
math.map([1, 2, 3], function (value) {
|
361
|
+
return value * value;
|
362
|
+
}),
|
363
|
+
[1, 4, 9]
|
364
|
+
);
|
319
365
|
}
|
320
366
|
|
321
367
|
// filter matrix
|
322
368
|
{
|
323
|
-
|
324
|
-
|
325
|
-
|
326
|
-
|
369
|
+
assert.deepStrictEqual(
|
370
|
+
math.filter([6, -2, -1, 4, 3], function (x) {
|
371
|
+
return x > 0;
|
372
|
+
}),
|
373
|
+
[6, 4, 3]
|
374
|
+
)
|
375
|
+
assert.deepStrictEqual(math.filter(['23', 'foo', '100', '55', 'bar'], /[0-9]+/), ["23", "100", "55"]);
|
327
376
|
}
|
328
377
|
|
329
378
|
// concat matrix
|
330
379
|
{
|
331
|
-
math.concat([[0, 1, 2]], [[1, 2, 3]])
|
332
|
-
math.concat([[0, 1, 2]], [[1, 2, 3]], 0)
|
380
|
+
assert.deepStrictEqual(math.concat([[0, 1, 2]], [[1, 2, 3]]), [[ 0, 1, 2, 1, 2, 3 ]]);
|
381
|
+
assert.deepStrictEqual(math.concat([[0, 1, 2]], [[1, 2, 3]], 0), [[ 0, 1, 2 ], [ 1, 2, 3 ]]);
|
382
|
+
}
|
383
|
+
|
384
|
+
// Matrix is available as a constructor for instanceof checks
|
385
|
+
{
|
386
|
+
assert.strictEqual(math.matrix([1, 2, 3]) instanceof math.Matrix, true)
|
333
387
|
}
|
334
388
|
}
|
335
389
|
|
@@ -347,7 +401,7 @@ Sparse matrices examples
|
|
347
401
|
const c = math.multiply(b, math.complex(2, 2));
|
348
402
|
const d = math.matrix([0, 1]);
|
349
403
|
const e = math.transpose(d);
|
350
|
-
const f = math.multiply(e,
|
404
|
+
const f = math.multiply(e, d);
|
351
405
|
}
|
352
406
|
|
353
407
|
/*
|
@@ -360,6 +414,7 @@ Units examples
|
|
360
414
|
// a string with a valued unit.
|
361
415
|
const a = math.unit(45, 'cm'); // 450 mm
|
362
416
|
const b = math.unit('0.1m'); // 100 mm
|
417
|
+
const c = math.unit(b)
|
363
418
|
|
364
419
|
// creating units
|
365
420
|
math.createUnit('foo');
|
@@ -380,7 +435,7 @@ Units examples
|
|
380
435
|
);
|
381
436
|
math.createUnit(
|
382
437
|
{
|
383
|
-
|
438
|
+
foo2: {
|
384
439
|
prefixes: 'long',
|
385
440
|
},
|
386
441
|
bar: '40 foo',
|
@@ -427,7 +482,7 @@ Expression tree examples
|
|
427
482
|
|
428
483
|
// Filter an expression tree
|
429
484
|
const node: math.MathNode = math.parse('x^2 + x/4 + 3*y');
|
430
|
-
const filtered: math.MathNode[] = node.filter((node: math.MathNode) => node.
|
485
|
+
const filtered: math.MathNode[] = node.filter((node: math.MathNode) => node.type === 'SymbolNode' && node.name === 'x');
|
431
486
|
|
432
487
|
const arr: string[] = filtered.map((node: math.MathNode) => node.toString());
|
433
488
|
|
@@ -442,7 +497,7 @@ Expression tree examples
|
|
442
497
|
case 'SymbolNode':
|
443
498
|
return node.type === 'SymbolNode';
|
444
499
|
default:
|
445
|
-
return
|
500
|
+
return;
|
446
501
|
}
|
447
502
|
});
|
448
503
|
}
|
@@ -454,22 +509,22 @@ Function floor examples
|
|
454
509
|
const math = create(all, {});
|
455
510
|
|
456
511
|
// number input
|
457
|
-
math.floor(3.2)
|
458
|
-
math.floor(-4.2)
|
512
|
+
assert.strictEqual(math.floor(3.2), 3);
|
513
|
+
assert.strictEqual(math.floor(-4.2), -5);
|
459
514
|
|
460
515
|
// number input
|
461
516
|
// roundoff result to 2 decimals
|
462
|
-
math.floor(3.212, 2)
|
463
|
-
math.floor(-4.212, 2)
|
517
|
+
assert.strictEqual(math.floor(3.212, 2), 3.21);
|
518
|
+
assert.strictEqual(math.floor(-4.212, 2), -4.22);
|
464
519
|
|
465
520
|
// Complex input
|
466
|
-
const c = math.complex(3.24, -2.71);
|
467
|
-
math.floor(c)
|
468
|
-
math.floor(c, 1)
|
521
|
+
const c = math.complex(3.24, -2.71);
|
522
|
+
assert.deepStrictEqual(math.floor(c), math.complex(3, -3));
|
523
|
+
assert.deepStrictEqual(math.floor(c, 1), math.complex(3.2, -2.8));
|
469
524
|
|
470
525
|
//array input
|
471
|
-
math.floor([3.2, 3.8, -4.7])
|
472
|
-
math.floor([3.21, 3.82, -4.71], 1)
|
526
|
+
assert.deepStrictEqual(math.floor([3.2, 3.8, -4.7]), [3, 3, -5]);
|
527
|
+
assert.deepStrictEqual(math.floor([3.21, 3.82, -4.71], 1), [3.2, 3.8, -4.8]);
|
473
528
|
}
|
474
529
|
|
475
530
|
|
@@ -483,8 +538,8 @@ JSON serialization/deserialization
|
|
483
538
|
bigNumber: math.bignumber('1.5'),
|
484
539
|
};
|
485
540
|
const stringified = JSON.stringify(data);
|
486
|
-
const parsed = JSON.parse(stringified, math.
|
487
|
-
parsed.bigNumber
|
541
|
+
const parsed = JSON.parse(stringified, math.reviver);
|
542
|
+
assert.deepStrictEqual(parsed.bigNumber, math.bignumber('1.5'));
|
488
543
|
}
|
489
544
|
|
490
545
|
/*
|
@@ -576,8 +631,8 @@ Factory Test
|
|
576
631
|
const b = fraction(3, 7);
|
577
632
|
const c = add(a, b);
|
578
633
|
const d = divide(a, b);
|
579
|
-
|
580
|
-
|
634
|
+
assert.strictEqual(format(c), "16/21");
|
635
|
+
assert.strictEqual(format(d), "7/9");
|
581
636
|
}
|
582
637
|
|
583
638
|
/**
|
@@ -592,8 +647,8 @@ Factory Test
|
|
592
647
|
};
|
593
648
|
|
594
649
|
// now we can use the \u260E (phone) character in expressions
|
595
|
-
const result = math.evaluate("\u260Efoo", { "\u260Efoo": 42 });
|
596
|
-
|
650
|
+
const result = math.evaluate("\u260Efoo", { "\u260Efoo": 42 });
|
651
|
+
assert.strictEqual(result, 42);
|
597
652
|
}
|
598
653
|
|
599
654
|
/**
|
@@ -604,13 +659,175 @@ Factory Test
|
|
604
659
|
const math = create(all, {});
|
605
660
|
|
606
661
|
// hasNumericValue function
|
607
|
-
math.hasNumericValue(2);
|
608
|
-
math.hasNumericValue('2');
|
609
|
-
math.isNumeric('2');
|
610
|
-
math.hasNumericValue(0);
|
611
|
-
math.hasNumericValue(math.bignumber(500));
|
612
|
-
math.hasNumericValue([2.3, 'foo', false])
|
613
|
-
math.hasNumericValue(math.fraction(4));
|
614
|
-
math.hasNumericValue(math.complex('2-4i'))
|
662
|
+
assert. strictEqual(math.hasNumericValue(2), true);
|
663
|
+
assert. strictEqual(math.hasNumericValue('2'), true);
|
664
|
+
assert. strictEqual(math.isNumeric('2'), false);
|
665
|
+
assert. strictEqual(math.hasNumericValue(0), true);
|
666
|
+
assert. strictEqual(math.hasNumericValue(math.bignumber(500)), true);
|
667
|
+
assert.deepStrictEqual(math.hasNumericValue([2.3, 'foo', false]), [true, false, true]);
|
668
|
+
assert. strictEqual(math.hasNumericValue(math.fraction(4)), true);
|
669
|
+
assert. strictEqual(math.hasNumericValue(math.complex('2-4i')), false);
|
615
670
|
}
|
616
671
|
|
672
|
+
/**
|
673
|
+
* src/util/is functions
|
674
|
+
*/
|
675
|
+
{
|
676
|
+
const math = create(all, {});
|
677
|
+
|
678
|
+
type IsFunc = (x: unknown) => boolean;
|
679
|
+
const isFuncs: IsFunc[] = [
|
680
|
+
math.isNumber,
|
681
|
+
math.isBigNumber,
|
682
|
+
math.isComplex,
|
683
|
+
math.isFraction,
|
684
|
+
math.isUnit,
|
685
|
+
math.isString,
|
686
|
+
math.isArray,
|
687
|
+
math.isMatrix,
|
688
|
+
math.isCollection,
|
689
|
+
math.isDenseMatrix,
|
690
|
+
math.isSparseMatrix,
|
691
|
+
math.isRange,
|
692
|
+
math.isIndex,
|
693
|
+
math.isBoolean,
|
694
|
+
math.isResultSet,
|
695
|
+
math.isHelp,
|
696
|
+
math.isFunction,
|
697
|
+
math.isDate,
|
698
|
+
math.isRegExp,
|
699
|
+
math.isObject,
|
700
|
+
math.isNull,
|
701
|
+
math.isUndefined,
|
702
|
+
math.isAccessorNode,
|
703
|
+
math.isArrayNode,
|
704
|
+
math.isAssignmentNode,
|
705
|
+
math.isBlockNode,
|
706
|
+
math.isConditionalNode,
|
707
|
+
math.isConstantNode,
|
708
|
+
math.isFunctionAssignmentNode,
|
709
|
+
math.isFunctionNode,
|
710
|
+
math.isIndexNode,
|
711
|
+
math.isNode,
|
712
|
+
math.isObjectNode,
|
713
|
+
math.isOperatorNode,
|
714
|
+
math.isParenthesisNode,
|
715
|
+
math.isRangeNode,
|
716
|
+
math.isSymbolNode,
|
717
|
+
math.isChain
|
718
|
+
]
|
719
|
+
|
720
|
+
isFuncs.forEach(f => {
|
721
|
+
const result = f(1);
|
722
|
+
const isResultBoolean = result === true || result === false;
|
723
|
+
assert.ok(isResultBoolean);
|
724
|
+
})
|
725
|
+
|
726
|
+
// Check guards do type refinement
|
727
|
+
|
728
|
+
let x: unknown
|
729
|
+
|
730
|
+
if (math.isNumber(x)) {
|
731
|
+
expectTypeOf(x).toMatchTypeOf<number>()
|
732
|
+
}
|
733
|
+
if (math.isBigNumber(x)) {
|
734
|
+
expectTypeOf(x).toMatchTypeOf<math.BigNumber>()
|
735
|
+
}
|
736
|
+
if (math.isComplex(x)) {
|
737
|
+
expectTypeOf(x).toMatchTypeOf<math.Complex>()
|
738
|
+
}
|
739
|
+
if (math.isFraction(x)) {
|
740
|
+
expectTypeOf(x).toMatchTypeOf<math.Fraction>()
|
741
|
+
}
|
742
|
+
if (math.isUnit(x)) {
|
743
|
+
expectTypeOf(x).toMatchTypeOf<math.Unit>()
|
744
|
+
}
|
745
|
+
if (math.isString(x)) {
|
746
|
+
expectTypeOf(x).toMatchTypeOf<string>()
|
747
|
+
}
|
748
|
+
if (math.isArray(x)) {
|
749
|
+
expectTypeOf(x).toMatchTypeOf<unknown[]>()
|
750
|
+
}
|
751
|
+
if (math.isMatrix(x)) {
|
752
|
+
expectTypeOf(x).toMatchTypeOf<math.Matrix>()
|
753
|
+
}
|
754
|
+
if (math.isDenseMatrix(x)) {
|
755
|
+
expectTypeOf(x).toMatchTypeOf<math.Matrix>()
|
756
|
+
}
|
757
|
+
if (math.isSparseMatrix(x)) {
|
758
|
+
expectTypeOf(x).toMatchTypeOf<math.Matrix>()
|
759
|
+
}
|
760
|
+
if (math.isIndex(x)) {
|
761
|
+
expectTypeOf(x).toMatchTypeOf<math.Index>()
|
762
|
+
}
|
763
|
+
if (math.isBoolean(x)) {
|
764
|
+
expectTypeOf(x).toMatchTypeOf<boolean>()
|
765
|
+
}
|
766
|
+
if (math.isHelp(x)) {
|
767
|
+
expectTypeOf(x).toMatchTypeOf<math.Help>()
|
768
|
+
}
|
769
|
+
if (math.isDate(x)) {
|
770
|
+
expectTypeOf(x).toMatchTypeOf<Date>()
|
771
|
+
}
|
772
|
+
if (math.isRegExp(x)) {
|
773
|
+
expectTypeOf(x).toMatchTypeOf<RegExp>()
|
774
|
+
}
|
775
|
+
if (math.isNull(x)) {
|
776
|
+
expectTypeOf(x).toMatchTypeOf<null>()
|
777
|
+
}
|
778
|
+
if (math.isUndefined(x)) {
|
779
|
+
expectTypeOf(x).toMatchTypeOf<undefined>()
|
780
|
+
}
|
781
|
+
|
782
|
+
if (math.isAccessorNode(x)) {
|
783
|
+
expectTypeOf(x).toMatchTypeOf<math.AccessorNode>()
|
784
|
+
}
|
785
|
+
if (math.isArrayNode(x)) {
|
786
|
+
expectTypeOf(x).toMatchTypeOf<math.ArrayNode>()
|
787
|
+
}
|
788
|
+
if (math.isAssignmentNode(x)) {
|
789
|
+
expectTypeOf(x).toMatchTypeOf<math.AssignmentNode>()
|
790
|
+
}
|
791
|
+
if (math.isBlockNode(x)) {
|
792
|
+
expectTypeOf(x).toMatchTypeOf<math.BlockNode>()
|
793
|
+
}
|
794
|
+
if (math.isConditionalNode(x)) {
|
795
|
+
expectTypeOf(x).toMatchTypeOf<math.ConditionalNode>()
|
796
|
+
}
|
797
|
+
if (math.isConstantNode(x)) {
|
798
|
+
expectTypeOf(x).toMatchTypeOf<math.ConstantNode>()
|
799
|
+
}
|
800
|
+
if (math.isFunctionAssignmentNode(x)) {
|
801
|
+
expectTypeOf(x).toMatchTypeOf<math.FunctionAssignmentNode>()
|
802
|
+
}
|
803
|
+
if (math.isFunctionNode(x)) {
|
804
|
+
expectTypeOf(x).toMatchTypeOf<math.FunctionNode>()
|
805
|
+
}
|
806
|
+
if (math.isIndexNode(x)) {
|
807
|
+
expectTypeOf(x).toMatchTypeOf<math.IndexNode>()
|
808
|
+
}
|
809
|
+
if (math.isNode(x)) {
|
810
|
+
expectTypeOf(x).toMatchTypeOf<math.MathNodeCommon>()
|
811
|
+
}
|
812
|
+
if (math.isNode(x)) {
|
813
|
+
expectTypeOf(x).toMatchTypeOf<math.MathNodeCommon>()
|
814
|
+
}
|
815
|
+
if (math.isObjectNode(x)) {
|
816
|
+
expectTypeOf(x).toMatchTypeOf<math.ObjectNode>()
|
817
|
+
}
|
818
|
+
if (math.isOperatorNode(x)) {
|
819
|
+
expectTypeOf(x).toMatchTypeOf<math.OperatorNode>()
|
820
|
+
}
|
821
|
+
if (math.isParenthesisNode(x)) {
|
822
|
+
expectTypeOf(x).toMatchTypeOf<math.ParenthesisNode>()
|
823
|
+
}
|
824
|
+
if (math.isRangeNode(x)) {
|
825
|
+
expectTypeOf(x).toMatchTypeOf<math.RangeNode>()
|
826
|
+
}
|
827
|
+
if (math.isSymbolNode(x)) {
|
828
|
+
expectTypeOf(x).toMatchTypeOf<math.SymbolNode>()
|
829
|
+
}
|
830
|
+
if (math.isChain(x)) {
|
831
|
+
expectTypeOf(x).toMatchTypeOf<math.MathJsChain>()
|
832
|
+
}
|
833
|
+
}
|
package/types/tsconfig.json
CHANGED
@@ -4,10 +4,11 @@
|
|
4
4
|
"paths": {
|
5
5
|
"mathjs": ["./index.d.ts"]
|
6
6
|
},
|
7
|
+
"moduleResolution": "node",
|
7
8
|
"typeRoots": [],
|
8
9
|
"types": [],
|
9
10
|
"lib": ["ES6", "DOM"],
|
10
|
-
"module": "
|
11
|
+
"module": "ESNEXT",
|
11
12
|
"noEmit": true,
|
12
13
|
"noImplicitAny": true,
|
13
14
|
"noImplicitThis": true,
|