mathjs 14.9.1 → 15.1.0

package/lib/esm/expression/node/ConstantNode.js

@@ -4,10 +4,11 @@ import { typeOf } from '../../utils/is.js';
 import { escapeLatex } from '../../utils/latex.js';
 import { factory } from '../../utils/factory.js';
 var name = 'ConstantNode';
-var dependencies = ['Node'];
+var dependencies = ['Node', 'isBounded'];
 export var createConstantNode = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
-    Node
+    Node,
+    isBounded
   } = _ref;
   class ConstantNode extends Node {
     /**
@@ -150,8 +151,7 @@ export var createConstantNode = /* #__PURE__ */factory(name, dependencies, _ref
         case 'number':
         case 'BigNumber':
           {
-            var finite = type === 'BigNumber' ? this.value.isFinite() : isFinite(this.value);
-            if (!finite) {
+            if (!isBounded(this.value)) {
               return this.value.valueOf() < 0 ? '-\\infty' : '\\infty';
             }
             var index = value.toLowerCase().indexOf('e');

package/lib/esm/expression/node/FunctionNode.js

@@ -100,7 +100,7 @@ export var createFunctionNode = /* #__PURE__ */factory(name, dependencies, _ref
      *     the arguments, typically a SymbolNode or AccessorNode
      * @param {./Node[]} args
      */
-    constructor(fn, args) {
+    constructor(fn, args, optional) {
       super();
       if (typeof fn === 'string') {
         fn = new SymbolNode(fn);
@@ -111,8 +111,13 @@ export var createFunctionNode = /* #__PURE__ */factory(name, dependencies, _ref
       if (!Array.isArray(args) || !args.every(isNode)) {
         throw new TypeError('Array containing Nodes expected for parameter "args"');
       }
+      var optionalType = typeof optional;
+      if (!(optionalType === 'undefined' || optionalType === 'boolean')) {
+        throw new TypeError('optional flag, if specified, must be boolean');
+      }
       this.fn = fn;
       this.args = args || [];
+      this.optional = !!optional;
     }
 
     // readonly property name
@@ -142,6 +147,7 @@ export var createFunctionNode = /* #__PURE__ */factory(name, dependencies, _ref
     _compile(math, argNames) {
       // compile arguments
       var evalArgs = this.args.map(arg => arg._compile(math, argNames));
+      var fromOptionalChaining = this.optional || isAccessorNode(this.fn) && this.fn.optionalChaining;
       if (isSymbolNode(this.fn)) {
         var _name = this.fn.name;
         if (!argNames[_name]) {
@@ -155,10 +161,8 @@ export var createFunctionNode = /* #__PURE__ */factory(name, dependencies, _ref
               value = scope.get(_name);
             } else if (_name in math) {
               value = getSafeProperty(math, _name);
-            } else {
-              return FunctionNode.onUndefinedFunction(_name);
-            }
-            if (typeof value === 'function') {
+            } else if (fromOptionalChaining) value = undefined;else return FunctionNode.onUndefinedFunction(_name);
+            if (typeof value === 'function' || fromOptionalChaining && value === undefined) {
               return value;
             }
             throw new TypeError("'".concat(_name, "' is not a function; its value is:\n  ").concat(strin(value)));
@@ -185,17 +189,20 @@ export var createFunctionNode = /* #__PURE__ */factory(name, dependencies, _ref
               case 0:
                 return function evalFunctionNode(scope, args, context) {
                   var fn = resolveFn(scope);
+                  if (fromOptionalChaining && fn === undefined) return undefined;
                   return fn();
                 };
               case 1:
                 return function evalFunctionNode(scope, args, context) {
                   var fn = resolveFn(scope);
+                  if (fromOptionalChaining && fn === undefined) return undefined;
                   var evalArg0 = evalArgs[0];
                   return fn(evalArg0(scope, args, context));
                 };
               case 2:
                 return function evalFunctionNode(scope, args, context) {
                   var fn = resolveFn(scope);
+                  if (fromOptionalChaining && fn === undefined) return undefined;
                   var evalArg0 = evalArgs[0];
                   var evalArg1 = evalArgs[1];
                   return fn(evalArg0(scope, args, context), evalArg1(scope, args, context));
@@ -203,6 +210,7 @@ export var createFunctionNode = /* #__PURE__ */factory(name, dependencies, _ref
               default:
                 return function evalFunctionNode(scope, args, context) {
                   var fn = resolveFn(scope);
+                  if (fromOptionalChaining && fn === undefined) return undefined;
                   var values = evalArgs.map(evalArg => evalArg(scope, args, context));
                   return fn(...values);
                 };
@@ -213,6 +221,7 @@ export var createFunctionNode = /* #__PURE__ */factory(name, dependencies, _ref
           var _rawArgs = this.args;
           return function evalFunctionNode(scope, args, context) {
             var fn = getSafeProperty(args, _name);
+            if (fromOptionalChaining && fn === undefined) return undefined;
             if (typeof fn !== 'function') {
               throw new TypeError("Argument '".concat(_name, "' was not a function; received: ").concat(strin(fn)));
             }
@@ -234,6 +243,11 @@ export var createFunctionNode = /* #__PURE__ */factory(name, dependencies, _ref
         var _rawArgs2 = this.args;
         return function evalFunctionNode(scope, args, context) {
           var object = evalObject(scope, args, context);
+
+          // Optional chaining: if the base object is nullish, short-circuit to undefined
+          if (fromOptionalChaining && (object == null || object[prop] === undefined)) {
+            return undefined;
+          }
           var fn = getSafeMethod(object, prop);
           if (fn !== null && fn !== void 0 && fn.rawArgs) {
             // "Raw" evaluation
@@ -253,6 +267,7 @@ export var createFunctionNode = /* #__PURE__ */factory(name, dependencies, _ref
         var _rawArgs3 = this.args;
         return function evalFunctionNode(scope, args, context) {
           var fn = evalFn(scope, args, context);
+          if (fromOptionalChaining && fn === undefined) return undefined;
           if (typeof fn !== 'function') {
             throw new TypeError("Expression '".concat(fnExpr, "' did not evaluate to a function; value is:") + "\n  ".concat(strin(fn)));
           }

package/lib/esm/expression/node/IndexNode.js

@@ -79,7 +79,7 @@ export var createIndexNode = /* #__PURE__ */factory(name, dependencies, _ref =>
             if (!isMatrix(context) && !isArray(context) && !isString(context)) {
               throw new TypeError('Cannot resolve "end": ' + 'context must be a Matrix, Array, or string but is ' + typeOf(context));
             }
-            var s = size(context).valueOf();
+            var s = size(context);
             var childArgs = Object.create(args);
             childArgs.end = s[i];
             return _evalDimension(scope, childArgs, context);

package/lib/esm/expression/parse.js

@@ -129,6 +129,7 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
     '=': true,
     ':': true,
     '?': true,
+    '?.': true,
     '??': true,
     '==': true,
     '!=': true,
@@ -295,7 +296,9 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
     }
 
     // check for delimiters consisting of 2 characters
-    if (c2.length === 2 && DELIMITERS[c2]) {
+    // Special case: the check for '?.' is to prevent a case like 'a?.3:.7' from being interpreted as optional chaining
+    // TODO: refactor the tokenization into some better way to deal with cases like 'a?.3:.7', see https://github.com/josdejong/mathjs/pull/3584
+    if (c2.length === 2 && DELIMITERS[c2] && (c2 !== '?.' || !parse.isDigit(state.expression.charAt(state.index + 2)))) {
       state.tokenType = TOKENTYPE.DELIMITER;
       state.token = c2;
       next(state);
@@ -322,7 +325,7 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
         next(state);
         state.token += currentCharacter(state);
         next(state);
-        while (parse.isHexDigit(currentCharacter(state))) {
+        while (parse.isAlpha(currentCharacter(state), prevCharacter(state), nextCharacter(state)) || parse.isDigit(currentCharacter(state))) {
           state.token += currentCharacter(state);
           next(state);
         }
@@ -331,7 +334,7 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
           state.token += '.';
           next(state);
           // get the digits after the radix
-          while (parse.isHexDigit(currentCharacter(state))) {
+          while (parse.isAlpha(currentCharacter(state), prevCharacter(state), nextCharacter(state)) || parse.isDigit(currentCharacter(state))) {
             state.token += currentCharacter(state);
             next(state);
           }
@@ -537,15 +540,6 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
     return c >= '0' && c <= '9';
   };
 
-  /**
-   * checks if the given char c is a hex digit
-   * @param {string} c   a string with one character
-   * @return {boolean}
-   */
-  parse.isHexDigit = function isHexDigit(c) {
-    return c >= '0' && c <= '9' || c >= 'a' && c <= 'f' || c >= 'A' && c <= 'F';
-  };
-
   /**
    * Start of the parse levels below, in order of precedence
    * @return {Node} node
@@ -649,6 +643,9 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
         return new AssignmentNode(new SymbolNode(name), value);
       } else if (isAccessorNode(node)) {
         // parse a matrix subset assignment like 'A[1,2] = 4'
+        if (node.optionalChaining) {
+          throw createSyntaxError(state, 'Cannot assign to optional chain');
+        }
         getTokenSkipNewline(state);
         value = parseAssignment(state);
         return new AssignmentNode(node.object, node.index, value);
@@ -934,7 +931,7 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
   function parseAddSubtract(state) {
     var node, name, fn, params;
-    node = parseMultiplyDivideModulusPercentage(state);
+    node = parseMultiplyDivideModulus(state);
     var operators = {
       '+': 'add',
       '-': 'subtract'
@@ -943,7 +940,7 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
       name = state.token;
       fn = operators[name];
       getTokenSkipNewline(state);
-      var rightNode = parseMultiplyDivideModulusPercentage(state);
+      var rightNode = parseMultiplyDivideModulus(state);
       if (rightNode.isPercentage) {
         params = [node, new OperatorNode('*', 'multiply', [node, rightNode])];
       } else {
@@ -955,11 +952,11 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
   }
 
   /**
-   * multiply, divide, modulus, percentage
+   * multiply, divide, modulus
    * @return {Node} node
    * @private
    */
-  function parseMultiplyDivideModulusPercentage(state) {
+  function parseMultiplyDivideModulus(state) {
     var node, last, name, fn;
     node = parseImplicitMultiplication(state);
     last = node;
@@ -977,23 +974,8 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
         name = state.token;
         fn = operators[name];
         getTokenSkipNewline(state);
-        if (name === '%' && state.tokenType === TOKENTYPE.DELIMITER && state.token !== '(') {
-          // If the expression contains only %, then treat that as /100
-          if (state.token !== '' && operators[state.token]) {
-            var left = new OperatorNode('/', 'divide', [node, new ConstantNode(100)], false, true);
-            name = state.token;
-            fn = operators[name];
-            getTokenSkipNewline(state);
-            last = parseImplicitMultiplication(state);
-            node = new OperatorNode(name, fn, [left, last]);
-          } else {
-            node = new OperatorNode('/', 'divide', [node, new ConstantNode(100)], false, true);
-          }
-          // return node
-        } else {
-          last = parseImplicitMultiplication(state);
-          node = new OperatorNode(name, fn, [node, last]);
-        }
+        last = parseImplicitMultiplication(state);
+        node = new OperatorNode(name, fn, [node, last]);
       } else {
         break;
       }
@@ -1036,7 +1018,7 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @private
    */
   function parseRule2(state) {
-    var node = parseUnary(state);
+    var node = parseUnaryPercentage(state);
     var last = node;
     var tokenStates = [];
     while (true) {
@@ -1058,7 +1040,7 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
             // Rewind once and build the "number / number" node; the symbol will be consumed later
             _extends(state, tokenStates.pop());
             tokenStates.pop();
-            last = parseUnary(state);
+            last = parseUnaryPercentage(state);
             node = new OperatorNode('/', 'divide', [node, last]);
           } else {
             // Not a match, so rewind
@@ -1078,6 +1060,34 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
     return node;
   }
 
+  /**
+   * Unary percentage operator (treated as `value / 100`)
+   * @return {Node} node
+   * @private
+   */
+  function parseUnaryPercentage(state) {
+    var node = parseUnary(state);
+    if (state.token === '%') {
+      var previousState = _extends({}, state);
+      getTokenSkipNewline(state);
+      // We need to decide if this is a unary percentage % or binary modulo %
+      // So we attempt to parse a unary expression at this point.
+      // If it fails, then the only possibility is that this is a unary percentage.
+      // If it succeeds, then we presume that this must be binary modulo, since the
+      // only things that parseUnary can handle are _higher_ precedence than unary %.
+      try {
+        parseUnary(state);
+        // Not sure if we could somehow use the result of that parseUnary? Without
+        // further analysis/testing, safer just to discard and let the parse proceed
+        _extends(state, previousState);
+      } catch (_unused) {
+        // Not seeing a term at this point, so was a unary %
+        node = new OperatorNode('/', 'divide', [node, new ConstantNode(100)], false, true);
+      }
+    }
+    return node;
+  }
+
   /**
    * Unary plus and minus, and logical and bitwise not
    * @return {Node} node
@@ -1250,9 +1260,9 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
 
   /**
    * parse accessors:
-   * - function invocation in round brackets (...), for example sqrt(2)
-   * - index enclosed in square brackets [...], for example A[2,3]
-   * - dot notation for properties, like foo.bar
+   * - function invocation in round brackets (...), for example sqrt(2) or sqrt?.(2) with optional chaining
+   * - index enclosed in square brackets [...], for example A[2,3] or A?.[2,3] with optional chaining
+   * - dot notation for properties, like foo.bar or foo?.bar with optional chaining
    * @param {Object} state
    * @param {Node} node    Node on which to apply the parameters. If there
    *                       are no parameters in the expression, the node
@@ -1264,12 +1274,27 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
   function parseAccessors(state, node, types) {
     var params;
-    while ((state.token === '(' || state.token === '[' || state.token === '.') && (!types || types.includes(state.token))) {
+
+    // Iterate and handle chained accessors, including repeated optional chaining
+    while (true) {
       // eslint-disable-line no-unmodified-loop-condition
+      // Track whether an optional chaining operator precedes the next accessor
+      var optional = false;
+
+      // Consume an optional chaining operator if present
+      if (state.token === '?.') {
+        optional = true;
+        // consume the '?.' token
+        getToken(state);
+      }
+      var hasNextAccessor = (state.token === '(' || state.token === '[' || state.token === '.') && (!types || types.includes(state.token));
+      if (!(optional || hasNextAccessor)) {
+        break;
+      }
       params = [];
       if (state.token === '(') {
-        if (isSymbolNode(node) || isAccessorNode(node)) {
-          // function invocation like fn(2, 3) or obj.fn(2, 3)
+        if (optional || isSymbolNode(node) || isAccessorNode(node)) {
+          // function invocation: fn(2, 3) or obj.fn(2, 3) or (anything)?.(2, 3)
           openParams(state);
           getToken(state);
           if (state.token !== ')') {
@@ -1287,7 +1312,7 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
           }
           closeParams(state);
           getToken(state);
-          node = new FunctionNode(node, params);
+          node = new FunctionNode(node, params, optional);
         } else {
           // implicit multiplication like (2+3)(4+5) or sqrt(2)(1+2)
           // don't parse it here but let it be handled by parseImplicitMultiplication
@@ -1313,18 +1338,21 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
         }
         closeParams(state);
         getToken(state);
-        node = new AccessorNode(node, new IndexNode(params));
+        node = new AccessorNode(node, new IndexNode(params), optional);
       } else {
         // dot notation like variable.prop
-        getToken(state);
+        // consume the `.` (if it was ?., already consumed):
+        if (!optional) getToken(state);
         var isPropertyName = state.tokenType === TOKENTYPE.SYMBOL || state.tokenType === TOKENTYPE.DELIMITER && state.token in NAMED_DELIMITERS;
         if (!isPropertyName) {
-          throw createSyntaxError(state, 'Property name expected after dot');
+          var message = 'Property name expected after ';
+          message += optional ? 'optional chain' : 'dot';
+          throw createSyntaxError(state, message);
         }
         params.push(new ConstantNode(state.token));
         getToken(state);
         var dotNotation = true;
-        node = new AccessorNode(node, new IndexNode(params, dotNotation));
+        node = new AccessorNode(node, new IndexNode(params, dotNotation), optional);
       }
     }
     return node;

package/lib/esm/factoriesAny.js

@@ -14,6 +14,8 @@ export { createHasNumericValue } from './function/utils/hasNumericValue.js';
 export { createIsPositive } from './function/utils/isPositive.js';
 export { createIsZero } from './function/utils/isZero.js';
 export { createIsNaN } from './function/utils/isNaN.js';
+export { createIsBounded } from './function/utils/isBounded.js';
+export { createIsFinite } from './function/utils/isFinite.js';
 export { createTypeOf } from './function/utils/typeOf.js';
 export { createEqualScalar } from './function/relational/equalScalar.js';
 export { createSparseMatrixClass } from './type/matrix/SparseMatrix.js';
@@ -242,6 +244,7 @@ export { createVariance } from './function/statistics/variance.js';
 export { createQuantileSeq } from './function/statistics/quantileSeq.js';
 export { createStd } from './function/statistics/std.js';
 export { createCorr } from './function/statistics/corr.js';
+export { createBernoulli } from './function/probability/bernoulli.js';
 export { createCombinations } from './function/probability/combinations.js';
 export { createCombinationsWithRep } from './function/probability/combinationsWithRep.js';
 export { createGamma } from './function/probability/gamma.js';

package/lib/esm/factoriesNumber.js

@@ -136,6 +136,7 @@ export var createSubset = /* #__PURE__ */factory('subset', [], () => noSubset);
 export { createPartitionSelect } from './function/matrix/partitionSelect.js';
 
 // probability
+export { createBernoulli } from './function/probability/bernoulli.js';
 export var createCombinations = createNumberFactory('combinations', combinationsNumber);
 export var createGamma = createNumberFactory('gamma', gammaNumber);
 export var createLgamma = createNumberFactory('lgamma', lgammaNumber);
@@ -236,6 +237,8 @@ export { createHasNumericValue } from './function/utils/hasNumericValue.js';
 export var createIsPositive = /* #__PURE__ */createNumberFactory('isPositive', isPositiveNumber);
 export var createIsZero = /* #__PURE__ */createNumberFactory('isZero', isZeroNumber);
 export var createIsNaN = /* #__PURE__ */createNumberFactory('isNaN', isNaNNumber);
+export { createIsBounded } from './function/utils/isBounded.js';
+export { createIsFinite } from './function/utils/isFinite.js';
 export { createTypeOf } from './function/utils/typeOf.js';
 export { createIsPrime } from './function/utils/isPrime.js';
 export { createNumeric } from './function/utils/numeric.js';

package/lib/esm/function/algebra/simplifyConstant.js

@@ -4,13 +4,14 @@ import { safeNumberType } from '../../utils/number.js';
 import { createUtil } from './simplify/util.js';
 import { noBignumber, noFraction } from '../../utils/noop.js';
 var name = 'simplifyConstant';
-var dependencies = ['typed', 'config', 'mathWithTransform', 'matrix', '?fraction', '?bignumber', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'SymbolNode'];
+var dependencies = ['typed', 'config', 'mathWithTransform', 'matrix', 'isBounded', '?fraction', '?bignumber', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'SymbolNode'];
 export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     config,
     mathWithTransform,
     matrix,
+    isBounded,
     fraction,
     bignumber,
     AccessorNode,
@@ -128,7 +129,7 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
   // and when both numerator and denominator are small enough
   function _exactFraction(n, options) {
     var exactFractions = options && options.exactFractions !== false;
-    if (exactFractions && isFinite(n) && fraction) {
+    if (exactFractions && isBounded(n) && fraction) {
       var f = fraction(n);
       var fractionsLimit = options && typeof options.fractionsLimit === 'number' ? options.fractionsLimit : Infinity; // no limit by default
 

package/lib/esm/function/algebra/sylvester.js

@@ -17,7 +17,8 @@ export var createSylvester = /* #__PURE__ */factory(name, dependencies, _ref =>
     subtract,
     identity,
     lusolve,
-    abs
+    abs,
+    config
   } = _ref;
   /**
    *
@@ -88,7 +89,7 @@ export var createSylvester = /* #__PURE__ */factory(name, dependencies, _ref =>
     var vc = (a, b) => concat(a, b, 0);
     for (var k = 0; k < n; k++) {
       if (k < n - 1 && abs(subset(G, index(k + 1, k))) > 1e-5) {
-        var RHS = vc(subset(D, index(all, k)), subset(D, index(all, k + 1)));
+        var RHS = vc(subset(D, index(all, [k])), subset(D, index(all, [k + 1])));
         for (var j = 0; j < k; j++) {
           RHS = add(RHS, vc(multiply(y[j], subset(G, index(j, k))), multiply(y[j], subset(G, index(j, k + 1)))));
         }
@@ -98,11 +99,11 @@ export var createSylvester = /* #__PURE__ */factory(name, dependencies, _ref =>
         var gmm = multiply(identity(m), multiply(-1, subset(G, index(k + 1, k + 1))));
         var LHS = vc(hc(add(F, gkk), gmk), hc(gkm, add(F, gmm)));
         var yAux = lusolve(LHS, RHS);
-        y[k] = yAux.subset(index(range(0, m), 0));
-        y[k + 1] = yAux.subset(index(range(m, 2 * m), 0));
+        y[k] = yAux.subset(index(range(0, m), [0]));
+        y[k + 1] = yAux.subset(index(range(m, 2 * m), [0]));
         k++;
       } else {
-        var _RHS = subset(D, index(all, k));
+        var _RHS = subset(D, index(all, [k]));
         for (var _j = 0; _j < k; _j++) {
           _RHS = add(_RHS, multiply(y[_j], subset(G, index(_j, k))));
         }

package/lib/esm/function/arithmetic/nthRoots.js

@@ -73,7 +73,11 @@ export var createNthRoots = /* #__PURE__ */factory(name, dependencies, _ref => {
    * Calculate the nth roots of a value.
    * An nth root of a positive real number A,
    * is a positive real solution of the equation "x^root = A".
-   * This function returns an array of complex values.
+   * This function returns an array of Complex values.
+   * Note that currently the precision of Complex numbers are limited
+   * to the precision of a 64-bit IEEE floating point, so even if the input
+   * is a BigNumber with greater precision, rounding to 64 bits will occur
+   * in computing the nth roots.
    *
    * Syntax:
    *

package/lib/esm/function/logical/nullish.js

@@ -62,8 +62,8 @@ export var createNullish = /* #__PURE__ */factory(name, dependencies, _ref => {
     'undefined, any': (_x, y) => y,
     // SparseMatrix-first with collection RHS: enforce exact shape match
     'SparseMatrix, Array | Matrix': (x, y) => {
-      var sx = flatten(size(x).valueOf()); // work around #3529/#3530
-      var sy = flatten(size(y).valueOf());
+      var sx = size(x);
+      var sy = size(y);
       if (deepEqual(sx, sy)) return x;
       throw new DimensionError(sx, sy);
     },

package/lib/esm/function/matrix/column.js

@@ -52,8 +52,9 @@ export var createColumn = /* #__PURE__ */factory(name, dependencies, _ref => {
     }
     validateIndex(column, value.size()[1]);
     var rowRange = range(0, value.size()[0]);
-    var index = new Index(rowRange, column);
+    var index = new Index(rowRange, [column]);
     var result = value.subset(index);
+    // once config.legacySubset just return result
     return isMatrix(result) ? result : matrix([[result]]);
   }
 });

package/lib/esm/function/matrix/dot.js

@@ -38,8 +38,8 @@ export var createDot = /* #__PURE__ */factory(name, dependencies, _ref => {
     'SparseMatrix, SparseMatrix': _sparseDot
   });
   function _validateDim(x, y) {
-    var xSize = _size(x);
-    var ySize = _size(y);
+    var xSize = size(x);
+    var ySize = size(y);
     var xLen, yLen;
     if (xSize.length === 1) {
       xLen = xSize[0];
@@ -67,8 +67,8 @@ export var createDot = /* #__PURE__ */factory(name, dependencies, _ref => {
     var bdt = isMatrix(b) ? b._datatype || b.getDataType() : undefined;
 
     // are these 2-dimensional column vectors? (as opposed to 1-dimensional vectors)
-    var aIsColumn = _size(a).length === 2;
-    var bIsColumn = _size(b).length === 2;
+    var aIsColumn = size(a).length === 2;
+    var bIsColumn = size(b).length === 2;
     var add = addScalar;
     var mul = multiplyScalar;
 
@@ -148,9 +148,4 @@ export var createDot = /* #__PURE__ */factory(name, dependencies, _ref => {
     }
     return c;
   }
-
-  // TODO remove this once #1771 is fixed
-  function _size(x) {
-    return isMatrix(x) ? x.size() : size(x);
-  }
 });

package/lib/esm/function/matrix/flatten.js

@@ -22,17 +22,20 @@ export var createFlatten = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *    concat, resize, size, squeeze
    *
-   * @param {Matrix | Array} x   Matrix to be flattened
-   * @return {Matrix | Array} Returns the flattened matrix
+   * @param {DenseMatrix | Array} x   Matrix to be flattened
+   * @return {DenseMatrix | Array} Returns the flattened matrix
    */
   return typed(name, {
     Array: function Array(x) {
       return flattenArray(x);
     },
-    Matrix: function Matrix(x) {
+    DenseMatrix: function DenseMatrix(x) {
       // Return the same matrix type as x (Dense or Sparse Matrix)
       // Return the same data type as x
       return x.create(flattenArray(x.valueOf(), true), x.datatype());
+    },
+    SparseMatrix: function SparseMatrix(_x) {
+      throw new TypeError('SparseMatrix is not supported by function flatten ' + 'because it does not support 1D vectors. ' + 'Convert to a DenseMatrix or Array first. Example: flatten(x.toArray())');
     }
   });
 });

package/lib/esm/function/matrix/kron.js

@@ -25,7 +25,7 @@ export var createKron = /* #__PURE__ */factory(name, dependencies, _ref => {
      *    // returns [ [ 1, 2, 0, 0 ], [ 3, 4, 0, 0 ], [ 0, 0, 1, 2 ], [ 0, 0, 3, 4 ] ]
      *
      *    math.kron([1,1], [2,3,4])
-     *    // returns [ [ 2, 3, 4, 2, 3, 4 ] ]
+     *    // returns [2, 3, 4, 2, 3, 4]
      *
      * See also:
      *
@@ -49,37 +49,38 @@ export var createKron = /* #__PURE__ */factory(name, dependencies, _ref => {
   });
 
   /**
-     * Calculate the Kronecker product of two matrices / vectors
-     * @param {Array} a  First vector
-     * @param {Array} b  Second vector
-     * @returns {Array} Returns the Kronecker product of x and y
-     * @private
+   * Calculate the Kronecker product of two (1-dimensional) vectors,
+   * with no dimension checking
+   * @param {Array} a  First vector
+   * @param {Array} b  Second vector
+   * @returns {Array}  the 1-dimensional Kronecker product of a and b
+   * @private
+   */
+  function _kron1d(a, b) {
+    // TODO in core overhaul: would be faster to see if we can choose a
+    // particular implementation of multiplyScalar at the beginning,
+    // rather than re-dispatch for _every_ ordered pair of entries.
+    return a.flatMap(x => b.map(y => multiplyScalar(x, y)));
+  }
+
+  /**
+   * Calculate the Kronecker product of two possibly multidimensional arrays
+   * @param {Array} a  First array
+   * @param {Array} b  Second array
+   * @param {number} [d]  common dimension; if missing, compute and match args
+   * @returns {Array} Returns the Kronecker product of x and y
+   * @private
      */
   function _kron(a, b) {
-    // Deal with the dimensions of the matricies.
-    if (size(a).length === 1) {
-      // Wrap it in a 2D Matrix
-      a = [a];
-    }
-    if (size(b).length === 1) {
-      // Wrap it in a 2D Matrix
-      b = [b];
-    }
-    if (size(a).length > 2 || size(b).length > 2) {
-      throw new RangeError('Vectors with dimensions greater then 2 are not supported expected ' + '(Size x = ' + JSON.stringify(a.length) + ', y = ' + JSON.stringify(b.length) + ')');
+    var d = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;
+    if (d < 0) {
+      var adim = size(a).length;
+      var bdim = size(b).length;
+      d = Math.max(adim, bdim);
+      while (adim++ < d) a = [a];
+      while (bdim++ < d) b = [b];
     }
-    var t = [];
-    var r = [];
-    return a.map(function (a) {
-      return b.map(function (b) {
-        r = [];
-        t.push(r);
-        return a.map(function (y) {
-          return b.map(function (x) {
-            return r.push(multiplyScalar(y, x));
-          });
-        });
-      });
-    }) && t;
+    if (d === 1) return _kron1d(a, b);
+    return a.flatMap(aSlice => b.map(bSlice => _kron(aSlice, bSlice, d - 1)));
   }
 });