mathjs 10.2.0 → 10.4.1

package/types/index.ts

@@ -8,6 +8,12 @@ import {
   divideDependencies,
   formatDependencies,
 } from 'mathjs';
+import * as assert from 'assert';
+import { expectTypeOf } from 'expect-type'
+
+// This file serves a dual purpose:
+// 1) examples of how to use math.js in TypeScript
+// 2) tests for the TypeScript declarations provided by math.js
 
 /*
 Basic usage examples
@@ -25,17 +31,45 @@ Basic usage examples
   const angle = 0.2;
   math.add(math.pow(math.sin(angle), 2), math.pow(math.cos(angle), 2));
 
+  // std and variance check
+  math.std(1, 2, 3)
+  math.std([1, 2, 3])
+  math.std([1, 2, 3], "biased")
+  math.std([1,2, 3], 0, "biased")
+  math.std([[1,2,3], [4,5,6]], 1, "unbiased")
+  math.std([[1,2,3], [4,5,6]], 1, "uncorrected")
+  math.variance(1, 2, 3)
+  math.variance([1, 2, 3])
+  math.variance([1, 2, 3], "biased")
+  math.variance([1,2, 3], 0, "biased")
+  math.variance([[1,2,3], [4,5,6]], 1, "unbiased")
+  math.variance([[1,2,3], [4,5,6]], 1, "uncorrected")
+
+  // std and variance on chain
+  math.chain([1, 2, 3]).std("unbiased")
+  math.chain([[1, 2, 3], [4, 5, 6]]).std(0, "biased").std(0, "uncorrected")
+  math.chain([[1, 2, 3], [4, 5, 6]]).std(0, "biased").std(0, "uncorrected")
+  math.chain([1, 2, 3]).std("unbiased")
+  math.chain([[1, 2, 3], [4, 5, 6]]).variance(0, "biased")
+  math.chain([[1, 2, 3], [4, 5, 6]]).variance(1, "uncorrected").variance("unbiased")
+
+
   // expressions
   math.evaluate('1.2 * (2 + 4.5)');
 
   // chained operations
-  const a = math.chain(3).add(4).multiply(2).done(); // 14
+  const a = math.chain(3).add(4).multiply(2).done();
+  assert.strictEqual(a, 14);
 
   // mixed use of different data types in functions
-  math.add(4, [5, 6]); // number + Array, [9, 10]
-  math.multiply(math.unit('5 mm'), 3); // Unit * number,  15 mm
-  math.subtract([2, 3, 4], 5); // Array - number, [-3, -2, -1]
-  math.add(math.matrix([2, 3]), [4, 5]); // Matrix + Array, [6, 8]
+  assert.deepStrictEqual(math.add(4, [5, 6]), [9, 10]); // number + Array
+  assert.deepStrictEqual(math.multiply(math.unit('5 mm'), 3), math.unit('15 mm')); // Unit * number
+  assert.deepStrictEqual(math.subtract([2, 3, 4], 5), [-3, -2, -1]); // Array - number
+  assert.deepStrictEqual(math.add(math.matrix([2, 3]), [4, 5]), math.matrix([6, 8])); // Matrix + Array
+
+  // narrowed type inference
+  const b: math.Matrix = math.add(math.matrix([2]), math.matrix([3]));
+  const c: math.Matrix = math.subtract(math.matrix([4]), math.matrix([5]));
 }
 
 /*
@@ -49,8 +83,8 @@ Bignumbers examples
   });
 
   {
-    math.add(math.bignumber(0.1), math.bignumber(0.2)); // BigNumber, 0.3
-    math.divide(math.bignumber(0.3), math.bignumber(0.2)); // BigNumber, 1.5
+    assert.deepStrictEqual(math.add(math.bignumber(0.1), math.bignumber(0.2)), math.bignumber(0.3));
+    assert.deepStrictEqual(math.divide(math.bignumber(0.3), math.bignumber(0.2)), math.bignumber(1.5));
   }
 }
 
@@ -59,14 +93,16 @@ Chaining examples
 */
 {
   const math = create(all, {});
-  const a = math.chain(3).add(4).multiply(2).done(); // 14
+  const a = math.chain(3).add(4).multiply(2).done();
+  assert.strictEqual(a, 14);
 
   // Another example, calculate square(sin(pi / 4))
   const b = math.chain(math.pi).divide(4).sin().square().done();
 
   // toString will return a string representation of the chain's value
   const chain = math.chain(2).divide(3);
-  const str: string = chain.toString(); // "0.6666666666666666"
+  const str: string = chain.toString();
+  assert.strictEqual(str, "0.6666666666666666");
 
   chain.valueOf();
 
@@ -75,17 +111,21 @@ Chaining examples
     [1, 2],
     [3, 4],
   ];
-  const v = math.chain(array).subset(math.index(1, 0)).done(); // 3
+  const v = math.chain(array).subset(math.index(1, 0)).done();
+  assert.strictEqual(v, 3);
 
   const m = math.chain(array).subset(math.index(0, 0), 8).multiply(3).done();
 
   // filtering
-  math
-    .chain([-1, 0, 1.1, 2, 3, 1000])
-    .filter(math.isPositive)
-    .filter(math.isInteger)
-    .filter((n) => n !== 1000)
-    .done(); // [2, 3]
+  assert.deepStrictEqual(
+    math
+      .chain([-1, 0, 1.1, 2, 3, 1000])
+      .filter(math.isPositive)
+      .filter(math.isInteger)
+      .filter((n) => n !== 1000)
+      .done(),
+    [2, 3]
+  );
 }
 
 /*
@@ -164,13 +204,16 @@ Expressions examples
   // get content of a parenthesis node
   {
     const node = math.parse('(1)');
+    if (node.type !== 'ParenthesisNode') {
+      throw Error(`expected ParenthesisNode, got ${node.type}`);
+    }
     const innerNode = node.content;
   }
 
   // scope can contain both variables and functions
   {
     const scope = { hello: (name: string) => `hello, ${name}!` };
-    math.evaluate('hello("hero")', scope); // "hello, hero!"
+    assert.strictEqual(math.evaluate('hello("hero")', scope), "hello, hero!");
   }
 
   // define a function as an expression
@@ -203,10 +246,10 @@ Expressions examples
 
   // get and set variables and functions
   {
-    parser.evaluate('x = 7 / 2'); // 3.5
-    parser.evaluate('x + 3'); // 6.5
+    assert.strictEqual(parser.evaluate('x = 7 / 2'), 3.5);
+    assert.strictEqual(parser.evaluate('x + 3'), 6.5);
     parser.evaluate('f(x, y) = x^y'); // f(x, y)
-    parser.evaluate('f(2, 3)'); // 8
+    assert.strictEqual(parser.evaluate('f(2, 3)'), 8);
 
     const x = parser.get('x');
     const f = parser.get('f');
@@ -277,7 +320,7 @@ Matrices examples
     b.subset(math.index(1, [0, 1]), [[7, 8]]);
     const c = math.multiply(a, b);
     const f: math.Matrix = math.matrix([1, 0]);
-    const d: math.Matrix = f.subset(math.index(1, 0));
+    const d: math.Matrix = f.subset(math.index(1));
   }
 
   // get a sub matrix
@@ -313,23 +356,34 @@ Matrices examples
 
   // map matrix
   {
-    math.map([1, 2, 3], function (value) {
-      return value * value;
-    }); // returns [1, 4, 9]
+    assert.deepStrictEqual(
+      math.map([1, 2, 3], function (value) {
+        return value * value;
+      }),
+      [1, 4, 9]
+    );
   }
 
   // filter matrix
   {
-    math.filter([6, -2, -1, 4, 3], function (x) {
-      return x > 0;
-    }); // returns [6, 4, 3]
-    math.filter(['23', 'foo', '100', '55', 'bar'], /[0-9]+/); // returns ["23", "100", "55"]
+    assert.deepStrictEqual(
+      math.filter([6, -2, -1, 4, 3], function (x) {
+        return x > 0;
+      }),
+      [6, 4, 3]
+    )
+    assert.deepStrictEqual(math.filter(['23', 'foo', '100', '55', 'bar'], /[0-9]+/), ["23", "100", "55"]);
   }
 
   // concat matrix
   {
-    math.concat([[0, 1, 2]], [[1, 2, 3]]); // returns [[ 0, 1, 2, 1, 2, 3 ]]
-    math.concat([[0, 1, 2]], [[1, 2, 3]], 0); // returns [[ 0, 1, 2 ], [ 1, 2, 3 ]]
+    assert.deepStrictEqual(math.concat([[0, 1, 2]], [[1, 2, 3]]), [[ 0, 1, 2, 1, 2, 3 ]]);
+    assert.deepStrictEqual(math.concat([[0, 1, 2]], [[1, 2, 3]], 0), [[ 0, 1, 2 ], [ 1, 2, 3 ]]);
+  }
+
+  // Matrix is available as a constructor for instanceof checks
+  {
+    assert.strictEqual(math.matrix([1, 2, 3]) instanceof math.Matrix, true)
   }
 }
 
@@ -347,7 +401,7 @@ Sparse matrices examples
   const c = math.multiply(b, math.complex(2, 2));
   const d = math.matrix([0, 1]);
   const e = math.transpose(d);
-  const f = math.multiply(e, a);
+  const f = math.multiply(e, d);
 }
 
 /*
@@ -360,6 +414,7 @@ Units examples
   // a string with a valued unit.
   const a = math.unit(45, 'cm'); // 450 mm
   const b = math.unit('0.1m'); // 100 mm
+  const c = math.unit(b)
 
   // creating units
   math.createUnit('foo');
@@ -380,7 +435,7 @@ Units examples
   );
   math.createUnit(
     {
-      foo_2: {
+      foo2: {
         prefixes: 'long',
       },
       bar: '40 foo',
@@ -427,7 +482,7 @@ Expression tree examples
 
   // Filter an expression tree
   const node: math.MathNode = math.parse('x^2 + x/4 + 3*y');
-  const filtered: math.MathNode[] = node.filter((node: math.MathNode) => node.isSymbolNode && node.name === 'x');
+  const filtered: math.MathNode[] = node.filter((node: math.MathNode) => node.type === 'SymbolNode' && node.name === 'x');
 
   const arr: string[] = filtered.map((node: math.MathNode) => node.toString());
 
@@ -442,7 +497,7 @@ Expression tree examples
       case 'SymbolNode':
         return node.type === 'SymbolNode';
       default:
-        return node.type === 'any string at all';
+        return;
     }
   });
 }
@@ -454,22 +509,22 @@ Function floor examples
   const math = create(all, {});
 
   // number input
-  math.floor(3.2); // returns number 3
-  math.floor(-4.2); // returns number -5
+  assert.strictEqual(math.floor(3.2), 3);
+  assert.strictEqual(math.floor(-4.2), -5);
 
   // number input
   // roundoff result to 2 decimals
-  math.floor(3.212, 2); // returns number 3.21
-  math.floor(-4.212, 2); // returns number -4.22
+  assert.strictEqual(math.floor(3.212, 2), 3.21);
+  assert.strictEqual(math.floor(-4.212, 2), -4.22);
 
   // Complex input
-  const c = math.complex(3.24, -2.71); // returns Complex 3 - 3i
-  math.floor(c); // returns Complex 3 - 3i
-  math.floor(c, 1); // returns Complex 3.2 - 2.8i
+  const c = math.complex(3.24, -2.71);
+  assert.deepStrictEqual(math.floor(c), math.complex(3, -3));
+  assert.deepStrictEqual(math.floor(c, 1), math.complex(3.2, -2.8));
 
   //array input
-  math.floor([3.2, 3.8, -4.7]); // returns Array [3, 3, -5]
-  math.floor([3.21, 3.82, -4.71], 1); // returns Array [3.2, 3.8, -4.8]
+  assert.deepStrictEqual(math.floor([3.2, 3.8, -4.7]), [3, 3, -5]);
+  assert.deepStrictEqual(math.floor([3.21, 3.82, -4.71], 1), [3.2, 3.8, -4.8]);
 }
 
 
@@ -483,8 +538,8 @@ JSON serialization/deserialization
     bigNumber: math.bignumber('1.5'),
   };
   const stringified = JSON.stringify(data);
-  const parsed = JSON.parse(stringified, math.json.reviver);
-  parsed.bigNumber === math.bignumber('1.5'); // true
+  const parsed = JSON.parse(stringified, math.reviver);
+  assert.deepStrictEqual(parsed.bigNumber, math.bignumber('1.5'));
 }
 
 /*
@@ -576,8 +631,8 @@ Factory Test
   const b = fraction(3, 7);
   const c = add(a, b);
   const d = divide(a, b);
-  console.log('c =', format(c)); // outputs "c = 16/21"
-  console.log('d =', format(d)); // outputs "d = 7/9"
+  assert.strictEqual(format(c), "16/21");
+  assert.strictEqual(format(d), "7/9");
 }
 
 /**
@@ -592,8 +647,8 @@ Factory Test
   };
 
   // now we can use the \u260E (phone) character in expressions
-  const result = math.evaluate("\u260Efoo", { "\u260Efoo": 42 }); // returns 42
-  console.log(result);
+  const result = math.evaluate("\u260Efoo", { "\u260Efoo": 42 });
+  assert.strictEqual(result, 42);
 }
 
 /**
@@ -604,13 +659,175 @@ Factory Test
   const math = create(all, {});
 
   // hasNumericValue function
-  math.hasNumericValue(2);                     // returns true
-  math.hasNumericValue('2');                   // returns true
-  math.isNumeric('2');                         // returns false
-  math.hasNumericValue(0);                     // returns true
-  math.hasNumericValue(math.bignumber(500));   // returns true
-  math.hasNumericValue([2.3, 'foo', false]);   // returns [true, false, true]
-  math.hasNumericValue(math.fraction(4));      // returns true
-  math.hasNumericValue(math.complex('2-4i'));  // returns false
+  assert.    strictEqual(math.hasNumericValue(2),                    true);
+  assert.    strictEqual(math.hasNumericValue('2'),                  true);
+  assert.    strictEqual(math.isNumeric('2'),                        false);
+  assert.    strictEqual(math.hasNumericValue(0),                    true);
+  assert.    strictEqual(math.hasNumericValue(math.bignumber(500)),  true);
+  assert.deepStrictEqual(math.hasNumericValue([2.3, 'foo', false]),  [true, false, true]);
+  assert.    strictEqual(math.hasNumericValue(math.fraction(4)),     true);
+  assert.    strictEqual(math.hasNumericValue(math.complex('2-4i')), false);
 }
 
+/**
+ * src/util/is functions
+ */
+{
+  const math = create(all, {});
+
+  type IsFunc = (x: unknown) => boolean;
+  const isFuncs: IsFunc[] = [
+    math.isNumber,
+    math.isBigNumber,
+    math.isComplex,
+    math.isFraction,
+    math.isUnit,
+    math.isString,
+    math.isArray,
+    math.isMatrix,
+    math.isCollection,
+    math.isDenseMatrix,
+    math.isSparseMatrix,
+    math.isRange,
+    math.isIndex,
+    math.isBoolean,
+    math.isResultSet,
+    math.isHelp,
+    math.isFunction,
+    math.isDate,
+    math.isRegExp,
+    math.isObject,
+    math.isNull,
+    math.isUndefined,
+    math.isAccessorNode,
+    math.isArrayNode,
+    math.isAssignmentNode,
+    math.isBlockNode,
+    math.isConditionalNode,
+    math.isConstantNode,
+    math.isFunctionAssignmentNode,
+    math.isFunctionNode,
+    math.isIndexNode,
+    math.isNode,
+    math.isObjectNode,
+    math.isOperatorNode,
+    math.isParenthesisNode,
+    math.isRangeNode,
+    math.isSymbolNode,
+    math.isChain
+  ]
+
+  isFuncs.forEach(f => {
+    const result = f(1);
+    const isResultBoolean = result === true || result === false;
+    assert.ok(isResultBoolean);
+  })
+
+  // Check guards do type refinement
+
+  let x: unknown
+
+  if (math.isNumber(x)) {
+    expectTypeOf(x).toMatchTypeOf<number>()
+  }
+  if (math.isBigNumber(x)) {
+    expectTypeOf(x).toMatchTypeOf<math.BigNumber>()
+  }
+  if (math.isComplex(x)) {
+    expectTypeOf(x).toMatchTypeOf<math.Complex>()
+  }
+  if (math.isFraction(x)) {
+    expectTypeOf(x).toMatchTypeOf<math.Fraction>()
+  }
+  if (math.isUnit(x)) {
+    expectTypeOf(x).toMatchTypeOf<math.Unit>()
+  }
+  if (math.isString(x)) {
+    expectTypeOf(x).toMatchTypeOf<string>()
+  }
+  if (math.isArray(x)) {
+    expectTypeOf(x).toMatchTypeOf<unknown[]>()
+  }
+  if (math.isMatrix(x)) {
+    expectTypeOf(x).toMatchTypeOf<math.Matrix>()
+  }
+  if (math.isDenseMatrix(x)) {
+    expectTypeOf(x).toMatchTypeOf<math.Matrix>()
+  }
+  if (math.isSparseMatrix(x)) {
+    expectTypeOf(x).toMatchTypeOf<math.Matrix>()
+  }
+  if (math.isIndex(x)) {
+    expectTypeOf(x).toMatchTypeOf<math.Index>()
+  }
+  if (math.isBoolean(x)) {
+    expectTypeOf(x).toMatchTypeOf<boolean>()
+  }
+  if (math.isHelp(x)) {
+    expectTypeOf(x).toMatchTypeOf<math.Help>()
+  }
+  if (math.isDate(x)) {
+    expectTypeOf(x).toMatchTypeOf<Date>()
+  }
+  if (math.isRegExp(x)) {
+    expectTypeOf(x).toMatchTypeOf<RegExp>()
+  }
+  if (math.isNull(x)) {
+    expectTypeOf(x).toMatchTypeOf<null>()
+  }
+  if (math.isUndefined(x)) {
+    expectTypeOf(x).toMatchTypeOf<undefined>()
+  }
+
+  if (math.isAccessorNode(x)) {
+    expectTypeOf(x).toMatchTypeOf<math.AccessorNode>()
+  }
+  if (math.isArrayNode(x)) {
+    expectTypeOf(x).toMatchTypeOf<math.ArrayNode>()
+  }
+  if (math.isAssignmentNode(x)) {
+    expectTypeOf(x).toMatchTypeOf<math.AssignmentNode>()
+  }
+  if (math.isBlockNode(x)) {
+    expectTypeOf(x).toMatchTypeOf<math.BlockNode>()
+  }
+  if (math.isConditionalNode(x)) {
+    expectTypeOf(x).toMatchTypeOf<math.ConditionalNode>()
+  }
+  if (math.isConstantNode(x)) {
+    expectTypeOf(x).toMatchTypeOf<math.ConstantNode>()
+  }
+  if (math.isFunctionAssignmentNode(x)) {
+    expectTypeOf(x).toMatchTypeOf<math.FunctionAssignmentNode>()
+  }
+  if (math.isFunctionNode(x)) {
+    expectTypeOf(x).toMatchTypeOf<math.FunctionNode>()
+  }
+  if (math.isIndexNode(x)) {
+    expectTypeOf(x).toMatchTypeOf<math.IndexNode>()
+  }
+  if (math.isNode(x)) {
+    expectTypeOf(x).toMatchTypeOf<math.MathNodeCommon>()
+  }
+  if (math.isNode(x)) {
+    expectTypeOf(x).toMatchTypeOf<math.MathNodeCommon>()
+  }
+  if (math.isObjectNode(x)) {
+    expectTypeOf(x).toMatchTypeOf<math.ObjectNode>()
+  }
+  if (math.isOperatorNode(x)) {
+    expectTypeOf(x).toMatchTypeOf<math.OperatorNode>()
+  }
+  if (math.isParenthesisNode(x)) {
+    expectTypeOf(x).toMatchTypeOf<math.ParenthesisNode>()
+  }
+  if (math.isRangeNode(x)) {
+    expectTypeOf(x).toMatchTypeOf<math.RangeNode>()
+  }
+  if (math.isSymbolNode(x)) {
+    expectTypeOf(x).toMatchTypeOf<math.SymbolNode>()
+  }
+  if (math.isChain(x)) {
+    expectTypeOf(x).toMatchTypeOf<math.MathJsChain>()
+  }
+}

package/types/tsconfig.json

@@ -4,10 +4,11 @@
     "paths": {
       "mathjs": ["./index.d.ts"]
     },
+    "moduleResolution": "node",
     "typeRoots": [],
     "types": [],
     "lib": ["ES6", "DOM"],
-    "module": "commonjs",
+    "module": "ESNEXT",
     "noEmit": true,
     "noImplicitAny": true,
     "noImplicitThis": true,