mathjs 14.3.1 → 14.5.0

package/lib/esm/utils/array.js

@@ -242,7 +242,7 @@ function _resize(array, size, dim, defaultValue) {
  *                                not equal that of the old ones
  */
 export function reshape(array, sizes) {
-  var flatArray = flatten(array);
+  var flatArray = flatten(array, true); // since it has rectangular
   var currentLength = flatArray.length;
   if (!Array.isArray(array) || !Array.isArray(sizes)) {
     throw new TypeError('Array expected');
@@ -439,22 +439,46 @@ function _unsqueeze(array, dims, dim) {
  * Flatten a multi dimensional array, put all elements in a one dimensional
  * array
  * @param {Array} array   A multi dimensional array
+ * @param {boolean} isRectangular Optional. If the array is rectangular (not jagged)
  * @return {Array}        The flattened array (1 dimensional)
  */
 export function flatten(array) {
+  var isRectangular = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
   if (!Array.isArray(array)) {
     // if not an array, return as is
     return array;
   }
+  if (typeof isRectangular !== 'boolean') {
+    throw new TypeError('Boolean expected for second argument of flatten');
+  }
   var flat = [];
-  array.forEach(function callback(value) {
-    if (Array.isArray(value)) {
-      value.forEach(callback); // traverse through sub-arrays recursively
+  if (isRectangular) {
+    _flattenRectangular(array);
+  } else {
+    _flatten(array);
+  }
+  return flat;
+  function _flatten(array) {
+    for (var i = 0; i < array.length; i++) {
+      var item = array[i];
+      if (Array.isArray(item)) {
+        _flatten(item);
+      } else {
+        flat.push(item);
+      }
+    }
+  }
+  function _flattenRectangular(array) {
+    if (Array.isArray(array[0])) {
+      for (var i = 0; i < array.length; i++) {
+        _flattenRectangular(array[i]);
+      }
     } else {
-      flat.push(value);
+      for (var _i = 0; _i < array.length; _i++) {
+        flat.push(array[_i]);
+      }
     }
-  });
-  return flat;
+  }
 }
 
 /**
@@ -689,8 +713,8 @@ export function broadcastSizes() {
       }
     }
   }
-  for (var _i = 0; _i < sizes.length; _i++) {
-    checkBroadcastingRules(sizes[_i], sizeMax);
+  for (var _i2 = 0; _i2 < sizes.length; _i2++) {
+    checkBroadcastingRules(sizes[_i2], sizeMax);
   }
   return sizeMax;
 }

package/lib/esm/utils/collection.js

@@ -27,7 +27,7 @@ export function containsCollections(array) {
  */
 export function deepForEach(array, callback) {
   if (isMatrix(array)) {
-    array.forEach(x => callback(x));
+    array.forEach(x => callback(x), false, true);
   } else {
     arrayDeepForEach(array, callback, true);
   }
@@ -48,14 +48,14 @@ export function deepForEach(array, callback) {
 export function deepMap(array, callback, skipZeros) {
   if (!skipZeros) {
     if (isMatrix(array)) {
-      return array.map(x => callback(x));
+      return array.map(x => callback(x), false, true);
     } else {
       return arrayDeepMap(array, callback, true);
     }
   }
   var skipZerosCallback = x => x === 0 ? x : callback(x);
   if (isMatrix(array)) {
-    return array.map(x => skipZerosCallback(x));
+    return array.map(x => skipZerosCallback(x), false, true);
   } else {
     return arrayDeepMap(array, skipZerosCallback, true);
   }

package/lib/esm/utils/latex.js

@@ -151,6 +151,9 @@ export var latexFunctions = {
   floor: {
     1: '\\left\\lfloor${args[0]}\\right\\rfloor'
   },
+  fraction: {
+    2: '\\frac{${args[0]}}{${args[1]}}'
+  },
   gcd: '\\gcd\\left(${args}\\right)',
   hypot: '\\hypot\\left(${args}\\right)',
   log: {
@@ -179,7 +182,7 @@ export var latexFunctions = {
     2: '\\sqrt[${args[1]}]{${args[0]}}'
   },
   nthRoots: {
-    2: '\\{y : $y^{args[1]} = {${args[0]}}\\}'
+    2: '\\{y : y^${args[1]} = {${args[0]}}\\}'
   },
   pow: {
     2: "\\left(${args[0]}\\right)".concat(latexOperators.pow, "{${args[1]}}")

package/lib/esm/utils/optimizeCallback.js

@@ -8,13 +8,20 @@ import { typeOf as _typeOf } from './is.js';
  * @param {Function} callback The original callback function to simplify.
  * @param {Array|Matrix} array The array that will be used with the callback function.
  * @param {string} name The name of the function that is using the callback.
+ * @param {boolean} [isUnary=false] If true, the callback function is unary and will be optimized as such.
  * @returns {Function} Returns a simplified version of the callback function.
  */
 export function optimizeCallback(callback, array, name) {
+  var isUnary = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
   if (typed.isTypedFunction(callback)) {
-    var firstIndex = (array.isMatrix ? array.size() : arraySize(array)).map(() => 0);
-    var firstValue = array.isMatrix ? array.get(firstIndex) : get(array, firstIndex);
-    var numberOfArguments = _findNumberOfArguments(callback, firstValue, firstIndex, array);
+    var numberOfArguments;
+    if (isUnary) {
+      numberOfArguments = 1;
+    } else {
+      var firstIndex = (array.isMatrix ? array.size() : arraySize(array)).map(() => 0);
+      var firstValue = array.isMatrix ? array.get(firstIndex) : get(array, firstIndex);
+      numberOfArguments = _findNumberOfArgumentsTyped(callback, firstValue, firstIndex, array);
+    }
     var fastCallback;
     if (array.isMatrix && array.dataType !== 'mixed' && array.dataType !== undefined) {
       var singleSignature = _findSingleSignatureWithArity(callback, numberOfArguments);
@@ -23,21 +30,37 @@ export function optimizeCallback(callback, array, name) {
       fastCallback = callback;
     }
     if (numberOfArguments >= 1 && numberOfArguments <= 3) {
-      return function () {
-        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-          args[_key] = arguments[_key];
+      return {
+        isUnary: numberOfArguments === 1,
+        fn: function fn() {
+          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+            args[_key] = arguments[_key];
+          }
+          return _tryFunctionWithArgs(fastCallback, args.slice(0, numberOfArguments), name, callback.name);
         }
-        return _tryFunctionWithArgs(fastCallback, args.slice(0, numberOfArguments), name, callback.name);
       };
     }
-    return function () {
-      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-        args[_key2] = arguments[_key2];
+    return {
+      isUnary: false,
+      fn: function fn() {
+        for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+          args[_key2] = arguments[_key2];
+        }
+        return _tryFunctionWithArgs(fastCallback, args, name, callback.name);
       }
-      return _tryFunctionWithArgs(fastCallback, args, name, callback.name);
     };
   }
-  return callback;
+  if (isUnary === undefined) {
+    return {
+      isUnary: _findIfCallbackIsUnary(callback),
+      fn: callback
+    };
+  } else {
+    return {
+      isUnary,
+      fn: callback
+    };
+  }
 }
 function _findSingleSignatureWithArity(callback, arity) {
   var matchingFunctions = [];
@@ -51,7 +74,32 @@ function _findSingleSignatureWithArity(callback, arity) {
     return matchingFunctions[0];
   }
 }
-function _findNumberOfArguments(callback, value, index, array) {
+
+/**
+ * Determines if a given callback function is unary (i.e., takes exactly one argument).
+ *
+ * This function checks the following conditions to determine if the callback is unary:
+ * 1. The callback function should have exactly one parameter.
+ * 2. The callback function should not use the `arguments` object.
+ * 3. The callback function should not use rest parameters (`...`).
+ * If in doubt, this function shall return `false` to be safe
+ *
+ * @param {Function} callback - The callback function to be checked.
+ * @returns {boolean} - Returns `true` if the callback is unary, otherwise `false`.
+ */
+function _findIfCallbackIsUnary(callback) {
+  if (callback.length !== 1) return false;
+  var callbackStr = callback.toString();
+  // Check if the callback function uses `arguments`
+  if (/arguments/.test(callbackStr)) return false;
+
+  // Extract the parameters of the callback function
+  var paramsStr = callbackStr.match(/\(.*?\)/);
+  // Check if the callback function uses rest parameters
+  if (/\.\.\./.test(paramsStr)) return false;
+  return true;
+}
+function _findNumberOfArgumentsTyped(callback, value, index, array) {
   var testArgs = [value, index, array];
   for (var i = 3; i > 0; i--) {
     var args = testArgs.slice(0, i);

package/lib/esm/version.js

@@ -1,3 +1,3 @@
-export var version = '14.3.1';
+export var version = '14.5.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": "14.3.1",
+  "version": "14.5.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,7 +25,7 @@
     "unit"
   ],
   "dependencies": {
-    "@babel/runtime": "^7.25.7",
+    "@babel/runtime": "^7.26.10",
     "complex.js": "^2.2.5",
     "decimal.js": "^10.4.3",
     "escape-latex": "^1.2.0",
@@ -36,21 +36,21 @@
     "typed-function": "^4.2.1"
   },
   "devDependencies": {
-    "@babel/core": "7.26.9",
-    "@babel/plugin-transform-object-assign": "7.25.9",
-    "@babel/plugin-transform-optional-catch-binding": "7.25.9",
-    "@babel/plugin-transform-runtime": "7.26.9",
-    "@babel/preset-env": "7.26.9",
-    "@babel/register": "7.25.9",
+    "@babel/core": "7.27.1",
+    "@babel/plugin-transform-object-assign": "7.27.1",
+    "@babel/plugin-transform-optional-catch-binding": "7.27.1",
+    "@babel/plugin-transform-runtime": "7.27.1",
+    "@babel/preset-env": "7.27.2",
+    "@babel/register": "7.27.1",
     "@types/assert": "1.5.11",
     "@types/mocha": "10.0.10",
-    "@typescript-eslint/eslint-plugin": "8.25.0",
-    "@typescript-eslint/parser": "8.25.0",
+    "@typescript-eslint/eslint-plugin": "8.32.1",
+    "@typescript-eslint/parser": "8.32.1",
     "assert": "2.1.0",
     "babel-loader": "10.0.0",
     "c8": "10.1.3",
     "codecov": "3.8.3",
-    "core-js": "3.40.0",
+    "core-js": "3.42.0",
     "del": "8.0.0",
     "dtslint": "4.2.1",
     "eigen": "0.2.2",
@@ -60,12 +60,12 @@
     "eslint-plugin-import": "2.31.0",
     "eslint-plugin-mocha": "10.5.0",
     "eslint-plugin-n": "16.6.2",
-    "eslint-plugin-prettier": "5.2.3",
+    "eslint-plugin-prettier": "5.4.0",
     "eslint-plugin-promise": "6.6.0",
-    "expect-type": "1.1.0",
+    "expect-type": "1.2.1",
     "expr-eval": "2.0.2",
     "fancy-log": "2.0.0",
-    "glob": "11.0.1",
+    "glob": "11.0.2",
     "gulp": "5.0.0",
     "gulp-babel": "8.0.0",
     "handlebars": "4.7.8",
@@ -78,7 +78,7 @@
     "karma-webdriver-launcher": "1.0.8",
     "karma-webpack": "5.0.1",
     "mkdirp": "3.0.1",
-    "mocha": "11.1.0",
+    "mocha": "11.4.0",
     "mocha-junit-reporter": "2.2.1",
     "ndarray": "1.0.19",
     "ndarray-determinant": "1.0.0",
@@ -86,14 +86,14 @@
     "ndarray-ops": "1.2.2",
     "ndarray-pack": "1.2.1",
     "numericjs": "1.2.6",
-    "prettier": "3.5.2",
+    "prettier": "3.5.3",
     "process": "0.11.10",
-    "sinon": "19.0.2",
+    "sinon": "20.0.0",
     "sylvester": "0.0.21",
-    "tinybench": "3.1.1",
+    "tinybench": "4.0.1",
     "ts-node": "10.9.2",
-    "typescript": "5.7.3",
-    "webpack": "5.98.0",
+    "typescript": "5.8.3",
+    "webpack": "5.99.9",
     "zeros": "1.0.0"
   },
   "type": "module",