mathjs 11.2.1 → 11.3.0

package/lib/esm/utils/string.js

@@ -1,17 +1,18 @@
 import { isBigNumber, isString, typeOf } from './is.js';
 import { format as formatNumber } from './number.js';
 import { format as formatBigNumber } from './bignumber/formatter.js';
+
 /**
  * Check if a text ends with a certain string.
  * @param {string} text
  * @param {string} search
  */
-
 export function endsWith(text, search) {
   var start = text.length - search.length;
   var end = text.length;
   return text.substring(start, end) === search;
 }
+
 /**
  * Format a value of any type into a string.
  *
@@ -50,28 +51,23 @@ export function endsWith(text, search) {
  *     have been more, they are deleted and replaced by an ellipsis).
  * @return {string} str
  */
-
 export function format(value, options) {
   var result = _format(value, options);
-
   if (options && typeof options === 'object' && 'truncate' in options && result.length > options.truncate) {
     return result.substring(0, options.truncate - 3) + '...';
   }
-
   return result;
 }
-
 function _format(value, options) {
   if (typeof value === 'number') {
     return formatNumber(value, options);
   }
-
   if (isBigNumber(value)) {
     return formatBigNumber(value, options);
-  } // note: we use unsafe duck-typing here to check for Fractions, this is
-  // ok here since we're only invoking toString or concatenating its values
-
+  }
 
+  // note: we use unsafe duck-typing here to check for Fractions, this is
+  // ok here since we're only invoking toString or concatenating its values
   if (looksLikeFraction(value)) {
     if (!options || options.fraction !== 'decimal') {
       // output as ratio, like '1/3'
@@ -81,19 +77,15 @@ function _format(value, options) {
       return value.toString();
     }
   }
-
   if (Array.isArray(value)) {
     return formatArray(value, options);
   }
-
   if (isString(value)) {
     return '"' + value + '"';
   }
-
   if (typeof value === 'function') {
     return value.syntax ? String(value.syntax) : 'function';
   }
-
   if (value && typeof value === 'object') {
     if (typeof value.format === 'function') {
       return value.format(options);
@@ -107,30 +99,25 @@ function _format(value, options) {
       return '{' + entries.join(', ') + '}';
     }
   }
-
   return String(value);
 }
+
 /**
  * Stringify a value into a string enclosed in double quotes.
  * Unescaped double quotes and backslashes inside the value are escaped.
  * @param {*} value
  * @return {string}
  */
-
-
 export function stringify(value) {
   var text = String(value);
   var escaped = '';
   var i = 0;
-
   while (i < text.length) {
     var c = text.charAt(i);
-
     if (c === '\\') {
       escaped += c;
       i++;
       c = text.charAt(i);
-
       if (c === '' || '"\\/bfnrtu'.indexOf(c) === -1) {
         escaped += '\\'; // no valid escape character -> escape it
       }
@@ -141,23 +128,22 @@ export function stringify(value) {
     } else {
       escaped += c;
     }
-
     i++;
   }
-
   return '"' + escaped + '"';
 }
+
 /**
  * Escape special HTML characters
  * @param {*} value
  * @return {string}
  */
-
 export function escape(value) {
   var text = String(value);
   text = text.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/'/g, '&#39;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
   return text;
 }
+
 /**
  * Recursively format an n-dimensional matrix
  * Example output: "[[1, 2], [3, 4]]"
@@ -168,53 +154,45 @@ export function escape(value) {
  *                                                options.
  * @returns {string} str
  */
-
 function formatArray(array, options) {
   if (Array.isArray(array)) {
     var str = '[';
     var len = array.length;
-
     for (var i = 0; i < len; i++) {
       if (i !== 0) {
         str += ', ';
       }
-
       str += formatArray(array[i], options);
     }
-
     str += ']';
     return str;
   } else {
     return format(array, options);
   }
 }
+
 /**
  * Check whether a value looks like a Fraction (unsafe duck-type check)
  * @param {*} value
  * @return {boolean}
  */
-
-
 function looksLikeFraction(value) {
   return value && typeof value === 'object' && typeof value.s === 'number' && typeof value.n === 'number' && typeof value.d === 'number' || false;
 }
+
 /**
  * Compare two strings
  * @param {string} x
  * @param {string} y
  * @returns {number}
  */
-
-
 export function compareText(x, y) {
   // we don't want to convert numbers to string, only accept string input
   if (!isString(x)) {
     throw new TypeError('Unexpected type of argument in function compareText ' + '(expected: string or Array or Matrix, actual: ' + typeOf(x) + ', index: 0)');
   }
-
   if (!isString(y)) {
     throw new TypeError('Unexpected type of argument in function compareText ' + '(expected: string or Array or Matrix, actual: ' + typeOf(y) + ', index: 1)');
   }
-
   return x === y ? 0 : x > y ? 1 : -1;
 }

package/lib/esm/utils/switch.js

@@ -9,16 +9,12 @@ export function _switch(mat) {
   var J = mat[0].length;
   var i, j;
   var ret = [];
-
   for (j = 0; j < J; j++) {
     var tmp = [];
-
     for (i = 0; i < I; i++) {
       tmp.push(mat[i][j]);
     }
-
     ret.push(tmp);
   }
-
   return ret;
 }

package/lib/esm/version.js

@@ -1,2 +1,3 @@
-export var version = '11.2.1'; // Note: This file is automatically generated when building math.js.
+export var version = '11.3.0';
+// Note: This file is automatically generated when building math.js.
 // Changes made in this file will be overwritten.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mathjs",
-  "version": "11.2.1",
+  "version": "11.3.0",
   "description": "Math.js is an extensive math library for JavaScript and Node.js. It features a flexible expression parser with support for symbolic computation, comes with a large set of built-in functions and constants, and offers an integrated solution to work with different data types like numbers, big numbers, complex numbers, fractions, units, and matrices.",
   "author": "Jos de Jong <wjosdejong@gmail.com> (https://github.com/josdejong)",
   "homepage": "https://mathjs.org",
@@ -25,9 +25,9 @@
     "unit"
   ],
   "dependencies": {
-    "@babel/runtime": "^7.19.0",
+    "@babel/runtime": "^7.19.4",
     "complex.js": "^2.1.1",
-    "decimal.js": "^10.4.0",
+    "decimal.js": "^10.4.1",
     "escape-latex": "^1.2.0",
     "fraction.js": "^4.2.0",
     "javascript-natural-sort": "^0.7.1",
@@ -36,28 +36,28 @@
     "typed-function": "^4.1.0"
   },
   "devDependencies": {
-    "@babel/core": "7.19.0",
+    "@babel/core": "7.19.3",
     "@babel/plugin-transform-object-assign": "7.18.6",
-    "@babel/plugin-transform-runtime": "7.18.10",
-    "@babel/preset-env": "7.19.0",
+    "@babel/plugin-transform-runtime": "7.19.1",
+    "@babel/preset-env": "7.19.4",
     "@babel/register": "7.18.9",
     "@types/assert": "1.5.6",
-    "@types/mocha": "9.1.1",
-    "@typescript-eslint/eslint-plugin": "5.37.0",
-    "@typescript-eslint/parser": "5.37.0",
+    "@types/mocha": "10.0.0",
+    "@typescript-eslint/eslint-plugin": "5.40.0",
+    "@typescript-eslint/parser": "5.40.0",
     "assert": "2.0.0",
     "babel-loader": "8.2.5",
     "benchmark": "2.1.4",
     "codecov": "3.8.3",
-    "core-js": "3.25.1",
+    "core-js": "3.25.5",
     "del": "6.1.1",
     "dtslint": "4.2.1",
-    "eslint": "8.23.1",
+    "eslint": "8.25.0",
     "eslint-config-prettier": "8.5.0",
     "eslint-config-standard": "17.0.0",
     "eslint-plugin-import": "2.26.0",
     "eslint-plugin-mocha": "10.1.0",
-    "eslint-plugin-n": "15.2.5",
+    "eslint-plugin-n": "15.3.0",
     "eslint-plugin-prettier": "4.2.1",
     "eslint-plugin-promise": "6.0.1",
     "expect-type": "0.14.2",
@@ -68,8 +68,8 @@
     "gulp-babel": "8.0.0",
     "handlebars": "4.7.7",
     "istanbul": "0.4.5",
-    "jsep": "1.3.6",
-    "karma": "6.4.0",
+    "jsep": "1.3.7",
+    "karma": "6.4.1",
     "karma-browserstack-launcher": "1.6.0",
     "karma-firefox-launcher": "2.1.2",
     "karma-mocha": "2.0.1",
@@ -78,6 +78,7 @@
     "math-expression-evaluator": "1.4.0",
     "mkdirp": "1.0.4",
     "mocha": "10.0.0",
+    "mocha-junit-reporter": "2.1.0",
     "ndarray": "1.0.19",
     "ndarray-determinant": "1.0.0",
     "ndarray-gemm": "1.0.0",
@@ -90,7 +91,7 @@
     "process": "0.11.10",
     "sylvester": "0.0.21",
     "ts-node": "10.9.1",
-    "typescript": "4.8.3",
+    "typescript": "4.8.4",
     "webpack": "5.74.0",
     "zeros": "1.0.0"
   },

package/types/index.d.ts

@@ -162,10 +162,10 @@ declare namespace math {
   }
 
   interface NodeCtor {
-    new (): MathNodeCommon
+    new (): MathNode
   }
 
-  interface AccessorNode extends MathNodeCommon {
+  interface AccessorNode extends MathNode {
     type: 'AccessorNode'
     isAccessorNode: true
     object: MathNode
@@ -176,7 +176,7 @@ declare namespace math {
     new (object: MathNode, index: IndexNode): AccessorNode
   }
 
-  interface ArrayNode extends MathNodeCommon {
+  interface ArrayNode extends MathNode {
     type: 'ArrayNode'
     isArrayNode: true
     items: MathNode[]
@@ -185,7 +185,7 @@ declare namespace math {
     new (items: MathNode[]): ArrayNode
   }
 
-  interface AssignmentNode extends MathNodeCommon {
+  interface AssignmentNode extends MathNode {
     type: 'AssignmentNode'
     isAssignmentNode: true
     object: SymbolNode | AccessorNode
@@ -202,7 +202,7 @@ declare namespace math {
     ): AssignmentNode
   }
 
-  interface BlockNode extends MathNodeCommon {
+  interface BlockNode extends MathNode {
     type: 'BlockNode'
     isBlockNode: true
     blocks: Array<{ node: MathNode; visible: boolean }>
@@ -213,7 +213,7 @@ declare namespace math {
     ): BlockNode
   }
 
-  interface ConditionalNode extends MathNodeCommon {
+  interface ConditionalNode extends MathNode {
     type: 'ConditionalNode'
     isConditionalNode: boolean
     condition: MathNode
@@ -228,7 +228,7 @@ declare namespace math {
     ): ConditionalNode
   }
 
-  interface ConstantNode extends MathNodeCommon {
+  interface ConstantNode extends MathNode {
     type: 'ConstantNode'
     isConstantNode: true
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -239,7 +239,7 @@ declare namespace math {
     new (constant: number): ConstantNode
   }
 
-  interface FunctionAssignmentNode extends MathNodeCommon {
+  interface FunctionAssignmentNode extends MathNode {
     type: 'FunctionAssignmentNode'
     isFunctionAssignmentNode: true
     name: string
@@ -250,7 +250,7 @@ declare namespace math {
     new (name: string, params: string[], expr: MathNode): FunctionAssignmentNode
   }
 
-  interface FunctionNode extends MathNodeCommon {
+  interface FunctionNode extends MathNode {
     type: 'FunctionNode'
     isFunctionNode: true
     fn: SymbolNode
@@ -260,7 +260,7 @@ declare namespace math {
     new (fn: MathNode | string, args: MathNode[]): FunctionNode
   }
 
-  interface IndexNode extends MathNodeCommon {
+  interface IndexNode extends MathNode {
     type: 'IndexNode'
     isIndexNode: true
     dimensions: MathNode[]
@@ -271,7 +271,7 @@ declare namespace math {
     new (dimensions: MathNode[], dotNotation: boolean): IndexNode
   }
 
-  interface ObjectNode extends MathNodeCommon {
+  interface ObjectNode extends MathNode {
     type: 'ObjectNode'
     isObjectNode: true
     properties: Record<string, MathNode>
@@ -320,7 +320,7 @@ declare namespace math {
     TOp extends OperatorNodeMap[TFn] = never,
     TFn extends OperatorNodeFn = never,
     TArgs extends MathNode[] = MathNode[]
-  > extends MathNodeCommon {
+  > extends MathNode {
     type: 'OperatorNode'
     isOperatorNode: true
     op: TOp
@@ -331,7 +331,7 @@ declare namespace math {
     isBinary(): boolean
   }
 
-  interface OperatorNodeCtor extends MathNodeCommon {
+  interface OperatorNodeCtor extends MathNode {
     new <
       TOp extends OperatorNodeMap[TFn],
       TFn extends OperatorNodeFn,
@@ -344,7 +344,7 @@ declare namespace math {
     ): OperatorNode<TOp, TFn, TArgs>
   }
   interface ParenthesisNode<TContent extends MathNode = MathNode>
-    extends MathNodeCommon {
+    extends MathNode {
     type: 'ParenthesisNode'
     isParenthesisNode: true
     content: TContent
@@ -355,7 +355,7 @@ declare namespace math {
     ): ParenthesisNode<TContent>
   }
 
-  interface RangeNode extends MathNodeCommon {
+  interface RangeNode extends MathNode {
     type: 'RangeNode'
     isRangeNode: true
     start: MathNode
@@ -366,7 +366,7 @@ declare namespace math {
     new (start: MathNode, end: MathNode, step?: MathNode): RangeNode
   }
 
-  interface RelationalNode extends MathNodeCommon {
+  interface RelationalNode extends MathNode {
     type: 'RelationalNode'
     isRelationalNode: true
     conditionals: string[]
@@ -376,7 +376,7 @@ declare namespace math {
     new (conditionals: string[], params: MathNode[]): RelationalNode
   }
 
-  interface SymbolNode extends MathNodeCommon {
+  interface SymbolNode extends MathNode {
     type: 'SymbolNode'
     isSymbolNode: true
     name: string
@@ -385,22 +385,10 @@ declare namespace math {
     new (name: string): SymbolNode
   }
 
-  type MathNode =
-    | AccessorNode
-    | ArrayNode
-    | AssignmentNode
-    | BlockNode
-    | ConditionalNode
-    | ConstantNode
-    | FunctionAssignmentNode
-    | FunctionNode
-    | IndexNode
-    | ObjectNode
-    | OperatorNode<OperatorNodeOp, OperatorNodeFn>
-    | ParenthesisNode
-    | RangeNode
-    | RelationalNode
-    | SymbolNode
+  /**
+   * @deprecated since version 11.3. Prefer `MathNode` instead
+   */
+  type MathNodeCommon = MathNode
 
   type MathJsFunctionName = keyof MathJsStatic
 
@@ -1910,6 +1898,13 @@ declare namespace math {
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
     ): any
 
+    /**
+     * Calculate the Moore–Penrose inverse of a matrix.
+     * @param x Matrix to be inversed
+     * @return The inverse of `x`.
+     */
+    pinv<T extends MathType>(x: T): T
+
     /**
      * Create an array from a range. By default, the range end is excluded.
      * This can be customized by providing an extra parameter includeEnd.
@@ -3146,7 +3141,7 @@ declare namespace math {
 
     isIndexNode(x: unknown): x is IndexNode
 
-    isNode(x: unknown): x is MathNodeCommon
+    isNode(x: unknown): x is MathNode
 
     isObjectNode(x: unknown): x is ObjectNode
 
@@ -3855,7 +3850,7 @@ declare namespace math {
     evaluate(scope?: any): any
   }
 
-  interface MathNodeCommon {
+  interface MathNode {
     isNode: true
     comment: string
     type: string

package/types/index.ts

@@ -27,7 +27,6 @@ import {
   MathJsChain,
   MathJsFunctionName,
   MathNode,
-  MathNodeCommon,
   MathNumericType,
   MathType,
   Matrix,
@@ -42,7 +41,10 @@ import {
   SimplifyRule,
   SLUDecomposition,
   SymbolNode,
+  MathNodeCommon,
   Unit,
+  Node,
+  isSymbolNode,
 } from 'mathjs'
 import * as assert from 'assert'
 import { expectTypeOf } from 'expect-type'
@@ -1004,7 +1006,6 @@ Expressions examples
     if (node.type !== 'ParenthesisNode') {
       throw Error(`expected ParenthesisNode, got ${node.type}`)
     }
-    const _innerNode = node.content
   }
 
   // scope can contain both variables and functions
@@ -1292,6 +1293,37 @@ Matrices examples
       )
     )
   }
+
+  // Moore–Penrose inverse
+  {
+    assert.ok(
+      math.deepEqual(
+        math.pinv([
+          [1, 2],
+          [3, 4],
+        ]),
+        [
+          [-2, 1],
+          [1.5, -0.5],
+        ]
+      )
+    )
+    assert.ok(
+      math.deepEqual(
+        math.pinv(
+          math.matrix([
+            [1, 2],
+            [3, 4],
+          ])
+        ),
+        math.matrix([
+          [-2, 1],
+          [1.5, -0.5],
+        ])
+      )
+    )
+    assert.ok(math.deepEqual(math.pinv(4), 0.25))
+  }
 }
 
 /*
@@ -1463,9 +1495,9 @@ Expression tree examples
   const math = create(all, {})
 
   // Filter an expression tree
-  const node: MathNode = math.parse('x^2 + x/4 + 3*y')
-  const filtered: MathNode[] = node.filter(
-    (node: MathNode) => node.type === 'SymbolNode' && node.name === 'x'
+  const node = math.parse('x^2 + x/4 + 3*y')
+  const filtered = node.filter(
+    (node) => isSymbolNode(node) && node.name === 'x'
   )
 
   const _arr: string[] = filtered.map((node: MathNode) => node.toString())
@@ -2171,10 +2203,10 @@ Factory Test
     expectTypeOf(x).toMatchTypeOf<IndexNode>()
   }
   if (math.isNode(x)) {
-    expectTypeOf(x).toMatchTypeOf<MathNodeCommon>()
+    expectTypeOf(x).toMatchTypeOf<MathNode>()
   }
   if (math.isNode(x)) {
-    expectTypeOf(x).toMatchTypeOf<MathNodeCommon>()
+    expectTypeOf(x).toMatchTypeOf<MathNode>()
   }
   if (math.isObjectNode(x)) {
     expectTypeOf(x).toMatchTypeOf<ObjectNode>()
@@ -2263,3 +2295,36 @@ Random examples
     MathJsChain<number[]>
   >()
 }
+
+/*
+MathNode examples
+*/
+{
+  class CustomNode extends Node {
+    a: MathNode
+    constructor(a: MathNode) {
+      super()
+      this.a = a
+    }
+  }
+
+  // Basic node
+  const instance1 = new Node()
+
+  // Built-in subclass of Node
+  const instance2 = new ConstantNode(2)
+
+  // Custom subclass of node
+  const instance3 = new CustomNode(new ConstantNode(2))
+
+  expectTypeOf(instance1).toMatchTypeOf<MathNode>()
+  expectTypeOf(instance1).toMatchTypeOf<MathNodeCommon>()
+
+  expectTypeOf(instance2).toMatchTypeOf<MathNode>()
+  expectTypeOf(instance2).toMatchTypeOf<MathNodeCommon>()
+  expectTypeOf(instance2).toMatchTypeOf<ConstantNode>()
+
+  expectTypeOf(instance3).toMatchTypeOf<MathNode>()
+  expectTypeOf(instance3).toMatchTypeOf<MathNodeCommon>()
+  expectTypeOf(instance3).toMatchTypeOf<CustomNode>()
+}

package/types/tsconfig.json

@@ -1,6 +1,7 @@
 {
   "compilerOptions": {
     "baseUrl": ".",
+    "target": "ES6",
     "paths": {
       "mathjs": ["./index.d.ts"]
     },