mathjs 10.6.2 → 11.0.0

package/lib/cjs/function/arithmetic/multiply.js

@@ -9,13 +9,11 @@ var _factory = require("../../utils/factory.js");
 
 var _is = require("../../utils/is.js");
 
-var _object = require("../../utils/object.js");
-
 var _array = require("../../utils/array.js");
 
-var _algorithm = require("../../type/matrix/utils/algorithm11.js");
+var _matAlgo11xS0s = require("../../type/matrix/utils/matAlgo11xS0s.js");
 
-var _algorithm2 = require("../../type/matrix/utils/algorithm14.js");
+var _matAlgo14xDs = require("../../type/matrix/utils/matAlgo14xDs.js");
 
 var name = 'multiply';
 var dependencies = ['typed', 'matrix', 'addScalar', 'multiplyScalar', 'equalScalar', 'dot'];
@@ -26,11 +24,11 @@ var createMultiply = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
       multiplyScalar = _ref.multiplyScalar,
       equalScalar = _ref.equalScalar,
       dot = _ref.dot;
-  var algorithm11 = (0, _algorithm.createAlgorithm11)({
+  var matAlgo11xS0s = (0, _matAlgo11xS0s.createMatAlgo11xS0s)({
     typed: typed,
     equalScalar: equalScalar
   });
-  var algorithm14 = (0, _algorithm2.createAlgorithm14)({
+  var matAlgo14xDs = (0, _matAlgo14xDs.createMatAlgo14xDs)({
     typed: typed
   });
 
@@ -830,17 +828,19 @@ var createMultiply = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
    */
 
 
-  return typed(name, (0, _object.extend)({
+  return typed(name, multiplyScalar, {
     // we extend the signatures of multiplyScalar with signatures dealing with matrices
-    'Array, Array': function ArrayArray(x, y) {
-      // check dimensions
-      _validateMatrixDimensions((0, _array.arraySize)(x), (0, _array.arraySize)(y)); // use dense matrix implementation
+    'Array, Array': typed.referTo('Matrix, Matrix', function (selfMM) {
+      return function (x, y) {
+        // check dimensions
+        _validateMatrixDimensions((0, _array.arraySize)(x), (0, _array.arraySize)(y)); // use dense matrix implementation
 
 
-      var m = this(matrix(x), matrix(y)); // return array or scalar
+        var m = selfMM(matrix(x), matrix(y)); // return array or scalar
 
-      return (0, _is.isMatrix)(m) ? m.valueOf() : m;
-    },
+        return (0, _is.isMatrix)(m) ? m.valueOf() : m;
+      };
+    }),
     'Matrix, Matrix': function MatrixMatrix(x, y) {
       // dimensions
       var xsize = x.size();
@@ -869,44 +869,49 @@ var createMultiply = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
 
       return _multiplyMatrixMatrix(x, y);
     },
-    'Matrix, Array': function MatrixArray(x, y) {
-      // use Matrix * Matrix implementation
-      return this(x, matrix(y));
-    },
-    'Array, Matrix': function ArrayMatrix(x, y) {
-      // use Matrix * Matrix implementation
-      return this(matrix(x, y.storage()), y);
-    },
+    'Matrix, Array': typed.referTo('Matrix,Matrix', function (selfMM) {
+      return function (x, y) {
+        return selfMM(x, matrix(y));
+      };
+    }),
+    'Array, Matrix': typed.referToSelf(function (self) {
+      return function (x, y) {
+        // use Matrix * Matrix implementation
+        return self(matrix(x, y.storage()), y);
+      };
+    }),
     'SparseMatrix, any': function SparseMatrixAny(x, y) {
-      return algorithm11(x, y, multiplyScalar, false);
+      return matAlgo11xS0s(x, y, multiplyScalar, false);
     },
     'DenseMatrix, any': function DenseMatrixAny(x, y) {
-      return algorithm14(x, y, multiplyScalar, false);
+      return matAlgo14xDs(x, y, multiplyScalar, false);
     },
     'any, SparseMatrix': function anySparseMatrix(x, y) {
-      return algorithm11(y, x, multiplyScalar, true);
+      return matAlgo11xS0s(y, x, multiplyScalar, true);
     },
     'any, DenseMatrix': function anyDenseMatrix(x, y) {
-      return algorithm14(y, x, multiplyScalar, true);
+      return matAlgo14xDs(y, x, multiplyScalar, true);
     },
     'Array, any': function ArrayAny(x, y) {
       // use matrix implementation
-      return algorithm14(matrix(x), y, multiplyScalar, false).valueOf();
+      return matAlgo14xDs(matrix(x), y, multiplyScalar, false).valueOf();
     },
     'any, Array': function anyArray(x, y) {
       // use matrix implementation
-      return algorithm14(matrix(y), x, multiplyScalar, true).valueOf();
+      return matAlgo14xDs(matrix(y), x, multiplyScalar, true).valueOf();
     },
     'any, any': multiplyScalar,
-    'any, any, ...any': function anyAnyAny(x, y, rest) {
-      var result = this(x, y);
+    'any, any, ...any': typed.referToSelf(function (self) {
+      return function (x, y, rest) {
+        var result = self(x, y);
 
-      for (var i = 0; i < rest.length; i++) {
-        result = this(result, rest[i]);
-      }
+        for (var i = 0; i < rest.length; i++) {
+          result = self(result, rest[i]);
+        }
 
-      return result;
-    }
-  }, multiplyScalar.signatures));
+        return result;
+      };
+    })
+  });
 });
 exports.createMultiply = createMultiply;

package/lib/cjs/function/arithmetic/multiplyScalar.js

@@ -38,16 +38,9 @@ var createMultiplyScalar = /* #__PURE__ */(0, _factory.factory)(name, dependenci
       return x.mul(y);
     },
     'number | Fraction | BigNumber | Complex, Unit': function numberFractionBigNumberComplexUnit(x, y) {
-      var res = y.clone();
-      res.value = res.value === null ? res._normalize(x) : this(res.value, x);
-      return res;
+      return y.multiply(x);
     },
-    'Unit, number | Fraction | BigNumber | Complex': function UnitNumberFractionBigNumberComplex(x, y) {
-      var res = x.clone();
-      res.value = res.value === null ? res._normalize(y) : this(res.value, y);
-      return res;
-    },
-    'Unit, Unit': function UnitUnit(x, y) {
+    'Unit, number | Fraction | BigNumber | Complex | Unit': function UnitNumberFractionBigNumberComplexUnit(x, y) {
       return x.multiply(y);
     }
   });

package/lib/cjs/function/arithmetic/norm.js

@@ -71,7 +71,7 @@ var createNorm = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
       // norm(x) = abs(x)
       return x.abs();
     },
-    boolean: function boolean(x) {
+    "boolean": function boolean(x) {
       // norm(x) = abs(x)
       return Math.abs(x);
     },
@@ -81,10 +81,6 @@ var createNorm = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
     Matrix: function Matrix(x) {
       return _norm(x, 2);
     },
-    'number | Complex | BigNumber | boolean, number | BigNumber | string': function numberComplexBigNumberBooleanNumberBigNumberString(x) {
-      // ignore second parameter, TODO: remove the option of second parameter for these types
-      return this(x);
-    },
     'Array, number | BigNumber | string': function ArrayNumberBigNumberString(x, p) {
       return _norm(matrix(x), p);
     },

package/lib/cjs/function/arithmetic/nthRoot.js

@@ -7,17 +7,15 @@ exports.createNthRootNumber = exports.createNthRoot = void 0;
 
 var _factory = require("../../utils/factory.js");
 
-var _algorithm = require("../../type/matrix/utils/algorithm01.js");
+var _matAlgo01xDSid = require("../../type/matrix/utils/matAlgo01xDSid.js");
 
-var _algorithm2 = require("../../type/matrix/utils/algorithm02.js");
+var _matAlgo02xDS = require("../../type/matrix/utils/matAlgo02xDS0.js");
 
-var _algorithm3 = require("../../type/matrix/utils/algorithm06.js");
+var _matAlgo06xS0S = require("../../type/matrix/utils/matAlgo06xS0S0.js");
 
-var _algorithm4 = require("../../type/matrix/utils/algorithm11.js");
+var _matAlgo11xS0s = require("../../type/matrix/utils/matAlgo11xS0s.js");
 
-var _algorithm5 = require("../../type/matrix/utils/algorithm13.js");
-
-var _algorithm6 = require("../../type/matrix/utils/algorithm14.js");
+var _matrixAlgorithmSuite = require("../../type/matrix/utils/matrixAlgorithmSuite.js");
 
 var _index = require("../../plain/number/index.js");
 
@@ -28,26 +26,24 @@ var createNthRoot = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fun
       matrix = _ref.matrix,
       equalScalar = _ref.equalScalar,
       _BigNumber = _ref.BigNumber;
-  var algorithm01 = (0, _algorithm.createAlgorithm01)({
+  var matAlgo01xDSid = (0, _matAlgo01xDSid.createMatAlgo01xDSid)({
     typed: typed
   });
-  var algorithm02 = (0, _algorithm2.createAlgorithm02)({
+  var matAlgo02xDS0 = (0, _matAlgo02xDS.createMatAlgo02xDS0)({
     typed: typed,
     equalScalar: equalScalar
   });
-  var algorithm06 = (0, _algorithm3.createAlgorithm06)({
+  var matAlgo06xS0S0 = (0, _matAlgo06xS0S.createMatAlgo06xS0S0)({
     typed: typed,
     equalScalar: equalScalar
   });
-  var algorithm11 = (0, _algorithm4.createAlgorithm11)({
+  var matAlgo11xS0s = (0, _matAlgo11xS0s.createMatAlgo11xS0s)({
     typed: typed,
     equalScalar: equalScalar
   });
-  var algorithm13 = (0, _algorithm5.createAlgorithm13)({
-    typed: typed
-  });
-  var algorithm14 = (0, _algorithm6.createAlgorithm14)({
-    typed: typed
+  var matrixAlgorithmSuite = (0, _matrixAlgorithmSuite.createMatrixAlgorithmSuite)({
+    typed: typed,
+    matrix: matrix
   });
   /**
    * Calculate the nth root of a value.
@@ -79,89 +75,81 @@ var createNthRoot = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fun
    * @return {number | Complex | Array | Matrix} Returns the nth root of `a`
    */
 
-  var complexErr = '' + 'Complex number not supported in function nthRoot. ' + 'Use nthRoots instead.';
+  function complexErr() {
+    throw new Error('Complex number not supported in function nthRoot. Use nthRoots instead.');
+  }
+
   return typed(name, {
     number: _index.nthRootNumber,
     'number, number': _index.nthRootNumber,
     BigNumber: function BigNumber(x) {
       return _bigNthRoot(x, new _BigNumber(2));
     },
-    Complex: function Complex(x) {
-      throw new Error(complexErr);
-    },
-    'Complex, number': function ComplexNumber(x, y) {
-      throw new Error(complexErr);
-    },
     'BigNumber, BigNumber': _bigNthRoot,
-    'Array | Matrix': function ArrayMatrix(x) {
-      return this(x, 2);
-    },
-    'SparseMatrix, SparseMatrix': function SparseMatrixSparseMatrix(x, y) {
-      // density must be one (no zeros in matrix)
-      if (y.density() === 1) {
-        // sparse + sparse
-        return algorithm06(x, y, this);
-      } else {
-        // throw exception
-        throw new Error('Root must be non-zero');
-      }
-    },
-    'SparseMatrix, DenseMatrix': function SparseMatrixDenseMatrix(x, y) {
-      return algorithm02(y, x, this, true);
-    },
-    'DenseMatrix, SparseMatrix': function DenseMatrixSparseMatrix(x, y) {
-      // density must be one (no zeros in matrix)
-      if (y.density() === 1) {
-        // dense + sparse
-        return algorithm01(x, y, this, false);
-      } else {
-        // throw exception
-        throw new Error('Root must be non-zero');
-      }
-    },
-    'DenseMatrix, DenseMatrix': function DenseMatrixDenseMatrix(x, y) {
-      return algorithm13(x, y, this);
-    },
-    'Array, Array': function ArrayArray(x, y) {
-      // use matrix implementation
-      return this(matrix(x), matrix(y)).valueOf();
-    },
-    'Array, Matrix': function ArrayMatrix(x, y) {
-      // use matrix implementation
-      return this(matrix(x), y);
-    },
-    'Matrix, Array': function MatrixArray(x, y) {
-      // use matrix implementation
-      return this(x, matrix(y));
-    },
-    'SparseMatrix, number | BigNumber': function SparseMatrixNumberBigNumber(x, y) {
-      return algorithm11(x, y, this, false);
-    },
-    'DenseMatrix, number | BigNumber': function DenseMatrixNumberBigNumber(x, y) {
-      return algorithm14(x, y, this, false);
-    },
-    'number | BigNumber, SparseMatrix': function numberBigNumberSparseMatrix(x, y) {
-      // density must be one (no zeros in matrix)
-      if (y.density() === 1) {
-        // sparse - scalar
-        return algorithm11(y, x, this, true);
-      } else {
-        // throw exception
-        throw new Error('Root must be non-zero');
-      }
-    },
-    'number | BigNumber, DenseMatrix': function numberBigNumberDenseMatrix(x, y) {
-      return algorithm14(y, x, this, true);
-    },
-    'Array, number | BigNumber': function ArrayNumberBigNumber(x, y) {
-      // use matrix implementation
-      return this(matrix(x), y).valueOf();
-    },
-    'number | BigNumber, Array': function numberBigNumberArray(x, y) {
-      // use matrix implementation
-      return this(x, matrix(y)).valueOf();
-    }
-  });
+    Complex: complexErr,
+    'Complex, number': complexErr,
+    Array: typed.referTo('DenseMatrix,number', function (selfDn) {
+      return function (x) {
+        return selfDn(matrix(x), 2).valueOf();
+      };
+    }),
+    DenseMatrix: typed.referTo('DenseMatrix,number', function (selfDn) {
+      return function (x) {
+        return selfDn(x, 2);
+      };
+    }),
+    SparseMatrix: typed.referTo('SparseMatrix,number', function (selfSn) {
+      return function (x) {
+        return selfSn(x, 2);
+      };
+    }),
+    'SparseMatrix, SparseMatrix': typed.referToSelf(function (self) {
+      return function (x, y) {
+        // density must be one (no zeros in matrix)
+        if (y.density() === 1) {
+          // sparse + sparse
+          return matAlgo06xS0S0(x, y, self);
+        } else {
+          // throw exception
+          throw new Error('Root must be non-zero');
+        }
+      };
+    }),
+    'DenseMatrix, SparseMatrix': typed.referToSelf(function (self) {
+      return function (x, y) {
+        // density must be one (no zeros in matrix)
+        if (y.density() === 1) {
+          // dense + sparse
+          return matAlgo01xDSid(x, y, self, false);
+        } else {
+          // throw exception
+          throw new Error('Root must be non-zero');
+        }
+      };
+    }),
+    'Array, SparseMatrix': typed.referTo('DenseMatrix,SparseMatrix', function (selfDS) {
+      return function (x, y) {
+        return selfDS(matrix(x), y);
+      };
+    }),
+    'number | BigNumber, SparseMatrix': typed.referToSelf(function (self) {
+      return function (x, y) {
+        // density must be one (no zeros in matrix)
+        if (y.density() === 1) {
+          // sparse - scalar
+          return matAlgo11xS0s(y, x, self, true);
+        } else {
+          // throw exception
+          throw new Error('Root must be non-zero');
+        }
+      };
+    })
+  }, matrixAlgorithmSuite({
+    scalar: 'number | BigNumber',
+    SD: matAlgo02xDS0,
+    Ss: matAlgo11xS0s,
+    sS: false
+  }));
   /**
    * Calculate the nth root of a for BigNumbers, solve x^root == a
    * https://rosettacode.org/wiki/Nth_root#JavaScript

package/lib/cjs/function/arithmetic/round.js

@@ -9,11 +9,11 @@ var _factory = require("../../utils/factory.js");
 
 var _collection = require("../../utils/collection.js");
 
-var _algorithm = require("../../type/matrix/utils/algorithm11.js");
+var _matAlgo11xS0s = require("../../type/matrix/utils/matAlgo11xS0s.js");
 
-var _algorithm2 = require("../../type/matrix/utils/algorithm12.js");
+var _matAlgo12xSfs = require("../../type/matrix/utils/matAlgo12xSfs.js");
 
-var _algorithm3 = require("../../type/matrix/utils/algorithm14.js");
+var _matAlgo14xDs = require("../../type/matrix/utils/matAlgo14xDs.js");
 
 var _index = require("../../plain/number/index.js");
 
@@ -27,15 +27,15 @@ var createRound = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
       zeros = _ref.zeros,
       BigNumber = _ref.BigNumber,
       DenseMatrix = _ref.DenseMatrix;
-  var algorithm11 = (0, _algorithm.createAlgorithm11)({
+  var matAlgo11xS0s = (0, _matAlgo11xS0s.createMatAlgo11xS0s)({
     typed: typed,
     equalScalar: equalScalar
   });
-  var algorithm12 = (0, _algorithm2.createAlgorithm12)({
+  var matAlgo12xSfs = (0, _matAlgo12xSfs.createMatAlgo12xSfs)({
     typed: typed,
     DenseMatrix: DenseMatrix
   });
-  var algorithm14 = (0, _algorithm3.createAlgorithm14)({
+  var matAlgo14xDs = (0, _matAlgo14xDs.createMatAlgo14xDs)({
     typed: typed
   });
   /**
@@ -130,42 +130,56 @@ var createRound = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
 
       return x.round(n.toNumber());
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      // deep map collection, skip zeros since round(0) = 0
-      return (0, _collection.deepMap)(x, this, true);
-    },
-    'SparseMatrix, number | BigNumber': function SparseMatrixNumberBigNumber(x, y) {
-      return algorithm11(x, y, this, false);
-    },
-    'DenseMatrix, number | BigNumber': function DenseMatrixNumberBigNumber(x, y) {
-      return algorithm14(x, y, this, false);
-    },
-    'Array, number | BigNumber': function ArrayNumberBigNumber(x, y) {
-      // use matrix implementation
-      return algorithm14(matrix(x), y, this, false).valueOf();
-    },
-    'number | Complex | BigNumber | Fraction, SparseMatrix': function numberComplexBigNumberFractionSparseMatrix(x, y) {
-      // check scalar is zero
-      if (equalScalar(x, 0)) {
-        // do not execute algorithm, result will be a zero matrix
-        return zeros(y.size(), y.storage());
-      }
-
-      return algorithm12(y, x, this, true);
-    },
-    'number | Complex | BigNumber | Fraction, DenseMatrix': function numberComplexBigNumberFractionDenseMatrix(x, y) {
-      // check scalar is zero
-      if (equalScalar(x, 0)) {
-        // do not execute algorithm, result will be a zero matrix
-        return zeros(y.size(), y.storage());
-      }
-
-      return algorithm14(y, x, this, true);
-    },
-    'number | Complex | BigNumber | Fraction, Array': function numberComplexBigNumberFractionArray(x, y) {
-      // use matrix implementation
-      return algorithm14(matrix(y), x, this, true).valueOf();
-    }
+    // deep map collection, skip zeros since round(0) = 0
+    'Array | Matrix': typed.referToSelf(function (self) {
+      return function (x) {
+        return (0, _collection.deepMap)(x, self, true);
+      };
+    }),
+    'SparseMatrix, number | BigNumber': typed.referToSelf(function (self) {
+      return function (x, y) {
+        return matAlgo11xS0s(x, y, self, false);
+      };
+    }),
+    'DenseMatrix, number | BigNumber': typed.referToSelf(function (self) {
+      return function (x, y) {
+        return matAlgo14xDs(x, y, self, false);
+      };
+    }),
+    'Array, number | BigNumber': typed.referToSelf(function (self) {
+      return function (x, y) {
+        // use matrix implementation
+        return matAlgo14xDs(matrix(x), y, self, false).valueOf();
+      };
+    }),
+    'number | Complex | BigNumber | Fraction, SparseMatrix': typed.referToSelf(function (self) {
+      return function (x, y) {
+        // check scalar is zero
+        if (equalScalar(x, 0)) {
+          // do not execute algorithm, result will be a zero matrix
+          return zeros(y.size(), y.storage());
+        }
+
+        return matAlgo12xSfs(y, x, self, true);
+      };
+    }),
+    'number | Complex | BigNumber | Fraction, DenseMatrix': typed.referToSelf(function (self) {
+      return function (x, y) {
+        // check scalar is zero
+        if (equalScalar(x, 0)) {
+          // do not execute algorithm, result will be a zero matrix
+          return zeros(y.size(), y.storage());
+        }
+
+        return matAlgo14xDs(y, x, self, true);
+      };
+    }),
+    'number | Complex | BigNumber | Fraction, Array': typed.referToSelf(function (self) {
+      return function (x, y) {
+        // use matrix implementation
+        return matAlgo14xDs(matrix(y), x, self, true).valueOf();
+      };
+    })
   });
 });
 exports.createRound = createRound;

package/lib/cjs/function/arithmetic/sign.js

@@ -60,17 +60,21 @@ var createSign = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
     Fraction: function Fraction(x) {
       return new _Fraction(x.s, 1);
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      // deep map collection, skip zeros since sign(0) = 0
-      return (0, _collection.deepMap)(x, this, true);
-    },
-    Unit: function Unit(x) {
-      if (!x._isDerived() && x.units[0].unit.offset !== 0) {
-        throw new TypeError('sign is ambiguous for units with offset');
-      }
+    // deep map collection, skip zeros since sign(0) = 0
+    'Array | Matrix': typed.referToSelf(function (self) {
+      return function (x) {
+        return (0, _collection.deepMap)(x, self, true);
+      };
+    }),
+    Unit: typed.referToSelf(function (self) {
+      return function (x) {
+        if (!x._isDerived() && x.units[0].unit.offset !== 0) {
+          throw new TypeError('sign is ambiguous for units with offset');
+        }
 
-      return this(x.value);
-    }
+        return typed.find(self, x.valueType())(x.value);
+      };
+    })
   });
 });
 exports.createSign = createSign;

package/lib/cjs/function/arithmetic/sqrt.js

@@ -7,8 +7,6 @@ exports.createSqrt = void 0;
 
 var _factory = require("../../utils/factory.js");
 
-var _collection = require("../../utils/collection.js");
-
 var name = 'sqrt';
 var dependencies = ['config', 'typed', 'Complex'];
 var createSqrt = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
@@ -19,7 +17,9 @@ var createSqrt = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
   /**
    * Calculate the square root of a value.
    *
-   * For matrices, the function is evaluated element wise.
+   * For matrices, if you want the matrix square root of a square matrix,
+   * use the `sqrtm` function. If you wish to apply `sqrt` elementwise to
+   * a matrix M, use `math.map(M, math.sqrt)`.
    *
    * Syntax:
    *
@@ -35,9 +35,9 @@ var createSqrt = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
    *
    *    square, multiply, cube, cbrt, sqrtm
    *
-   * @param {number | BigNumber | Complex | Array | Matrix | Unit} x
+   * @param {number | BigNumber | Complex | Unit} x
    *            Value for which to calculate the square root.
-   * @return {number | BigNumber | Complex | Array | Matrix | Unit}
+   * @return {number | BigNumber | Complex | Unit}
    *            Returns the square root of `x`
    */
   return typed('sqrt', {
@@ -53,10 +53,6 @@ var createSqrt = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
         return _sqrtNumber(x.toNumber());
       }
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      // deep map collection, skip zeros since sqrt(0) = 0
-      return (0, _collection.deepMap)(x, this, true);
-    },
     Unit: function Unit(x) {
       // Someday will work for complex units when they are implemented
       return x.pow(0.5);

package/lib/cjs/function/arithmetic/square.js

@@ -7,8 +7,6 @@ exports.createSquare = void 0;
 
 var _factory = require("../../utils/factory.js");
 
-var _collection = require("../../utils/collection.js");
-
 var _index = require("../../plain/number/index.js");
 
 var name = 'square';
@@ -18,7 +16,9 @@ var createSquare = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
 
   /**
    * Compute the square of a value, `x * x`.
-   * For matrices, the function is evaluated element wise.
+   * To avoid confusion with multiplying a square matrix by itself,
+   * this function does not apply to matrices. If you wish to square
+   * every element of a matrix, see the examples.
    *
    * Syntax:
    *
@@ -31,15 +31,15 @@ var createSquare = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
    *    math.pow(3, 2)           // returns number 9
    *    math.multiply(3, 3)      // returns number 9
    *
-   *    math.square([1, 2, 3, 4])  // returns Array [1, 4, 9, 16]
+   *    math.map([1, 2, 3, 4], math.square)  // returns Array [1, 4, 9, 16]
    *
    * See also:
    *
    *    multiply, cube, sqrt, pow
    *
-   * @param  {number | BigNumber | Fraction | Complex | Array | Matrix | Unit} x
+   * @param  {number | BigNumber | Fraction | Complex | Unit} x
    *            Number for which to calculate the square
-   * @return {number | BigNumber | Fraction | Complex | Array | Matrix | Unit}
+   * @return {number | BigNumber | Fraction | Complex | Unit}
    *            Squared value
    */
   return typed(name, {
@@ -53,10 +53,6 @@ var createSquare = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
     Fraction: function Fraction(x) {
       return x.mul(x);
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      // deep map collection, skip zeros since square(0) = 0
-      return (0, _collection.deepMap)(x, this, true);
-    },
     Unit: function Unit(x) {
       return x.pow(2);
     }