mathjs-min 11.7.2

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

@@ -0,0 +1,63 @@
+import { reshape as arrayReshape } from '../../utils/array.js';
+import { factory } from '../../utils/factory.js';
+var name = 'reshape';
+var dependencies = ['typed', 'isInteger', 'matrix'];
+export var createReshape = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    isInteger
+  } = _ref;
+  /**
+   * Reshape a multi dimensional array to fit the specified dimensions
+   *
+   * Syntax:
+   *
+   *     math.reshape(x, sizes)
+   *
+   * Examples:
+   *
+   *     math.reshape([1, 2, 3, 4, 5, 6], [2, 3])
+   *     // returns Array  [[1, 2, 3], [4, 5, 6]]
+   *
+   *     math.reshape([[1, 2], [3, 4]], [1, 4])
+   *     // returns Array  [[1, 2, 3, 4]]
+   *
+   *     math.reshape([[1, 2], [3, 4]], [4])
+   *     // returns Array [1, 2, 3, 4]
+   *
+   *     const x = math.matrix([1, 2, 3, 4, 5, 6, 7, 8])
+   *     math.reshape(x, [2, 2, 2])
+   *     // returns Matrix [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
+   *
+   *    math.reshape([1, 2, 3, 4], [-1, 2])
+   *    // returns Matrix [[1, 2], [3, 4]]
+   *
+   * See also:
+   *
+   *     size, squeeze, resize
+   *
+   * @param {Array | Matrix | *} x  Matrix to be reshaped
+   * @param {number[]} sizes        One dimensional array with integral sizes for
+   *                                each dimension. One -1 is allowed as wildcard,
+   *                                which calculates this dimension automatically.
+   *
+   * @return {* | Array | Matrix}   A reshaped clone of matrix `x`
+   *
+   * @throws {TypeError}            If `sizes` does not contain solely integers
+   * @throws {DimensionError}       If the product of the new dimension sizes does
+   *                                not equal that of the old ones
+   */
+  return typed(name, {
+    'Matrix, Array': function MatrixArray(x, sizes) {
+      return x.reshape(sizes, true);
+    },
+    'Array, Array': function ArrayArray(x, sizes) {
+      sizes.forEach(function (size) {
+        if (!isInteger(size)) {
+          throw new TypeError('Invalid size for dimension: ' + size);
+        }
+      });
+      return arrayReshape(x, sizes);
+    }
+  });
+});

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

@@ -0,0 +1,121 @@
+import { isBigNumber, isMatrix } from '../../utils/is.js';
+import { DimensionError } from '../../error/DimensionError.js';
+import { ArgumentsError } from '../../error/ArgumentsError.js';
+import { isInteger } from '../../utils/number.js';
+import { format } from '../../utils/string.js';
+import { clone } from '../../utils/object.js';
+import { resize as arrayResize } from '../../utils/array.js';
+import { factory } from '../../utils/factory.js';
+var name = 'resize';
+var dependencies = ['config', 'matrix'];
+export var createResize = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    config,
+    matrix
+  } = _ref;
+  /**
+   * Resize a matrix
+   *
+   * Syntax:
+   *
+   *     math.resize(x, size)
+   *     math.resize(x, size, defaultValue)
+   *
+   * Examples:
+   *
+   *     math.resize([1, 2, 3, 4, 5], [3]) // returns Array  [1, 2, 3]
+   *     math.resize([1, 2, 3], [5], 0)    // returns Array  [1, 2, 3, 0, 0]
+   *     math.resize(2, [2, 3], 0)         // returns Matrix [[2, 0, 0], [0, 0, 0]]
+   *     math.resize("hello", [8], "!")    // returns string 'hello!!!'
+   *
+   * See also:
+   *
+   *     size, squeeze, subset, reshape
+   *
+   * @param {Array | Matrix | *} x             Matrix to be resized
+   * @param {Array | Matrix} size              One dimensional array with numbers
+   * @param {number | string} [defaultValue=0] Zero by default, except in
+   *                                           case of a string, in that case
+   *                                           defaultValue = ' '
+   * @return {* | Array | Matrix} A resized clone of matrix `x`
+   */
+  // TODO: rework resize to a typed-function
+  return function resize(x, size, defaultValue) {
+    if (arguments.length !== 2 && arguments.length !== 3) {
+      throw new ArgumentsError('resize', arguments.length, 2, 3);
+    }
+    if (isMatrix(size)) {
+      size = size.valueOf(); // get Array
+    }
+
+    if (isBigNumber(size[0])) {
+      // convert bignumbers to numbers
+      size = size.map(function (value) {
+        return !isBigNumber(value) ? value : value.toNumber();
+      });
+    }
+
+    // check x is a Matrix
+    if (isMatrix(x)) {
+      // use optimized matrix implementation, return copy
+      return x.resize(size, defaultValue, true);
+    }
+    if (typeof x === 'string') {
+      // resize string
+      return _resizeString(x, size, defaultValue);
+    }
+
+    // check result should be a matrix
+    var asMatrix = Array.isArray(x) ? false : config.matrix !== 'Array';
+    if (size.length === 0) {
+      // output a scalar
+      while (Array.isArray(x)) {
+        x = x[0];
+      }
+      return clone(x);
+    } else {
+      // output an array/matrix
+      if (!Array.isArray(x)) {
+        x = [x];
+      }
+      x = clone(x);
+      var res = arrayResize(x, size, defaultValue);
+      return asMatrix ? matrix(res) : res;
+    }
+  };
+
+  /**
+   * Resize a string
+   * @param {string} str
+   * @param {number[]} size
+   * @param {string} [defaultChar=' ']
+   * @private
+   */
+  function _resizeString(str, size, defaultChar) {
+    if (defaultChar !== undefined) {
+      if (typeof defaultChar !== 'string' || defaultChar.length !== 1) {
+        throw new TypeError('Single character expected as defaultValue');
+      }
+    } else {
+      defaultChar = ' ';
+    }
+    if (size.length !== 1) {
+      throw new DimensionError(size.length, 1);
+    }
+    var len = size[0];
+    if (typeof len !== 'number' || !isInteger(len)) {
+      throw new TypeError('Invalid size, must contain positive integers ' + '(size: ' + format(size) + ')');
+    }
+    if (str.length > len) {
+      return str.substring(0, len);
+    } else if (str.length < len) {
+      var res = str;
+      for (var i = 0, ii = len - str.length; i < ii; i++) {
+        res += defaultChar;
+      }
+      return res;
+    } else {
+      return str;
+    }
+  }
+});

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

@@ -0,0 +1,71 @@
+import { factory } from '../../utils/factory.js';
+import { arraySize } from '../../utils/array.js';
+var name = 'rotate';
+var dependencies = ['typed', 'multiply', 'rotationMatrix'];
+export var createRotate = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    multiply,
+    rotationMatrix
+  } = _ref;
+  /**
+     * Rotate a vector of size 1x2 counter-clockwise by a given angle
+     * Rotate a vector of size 1x3 counter-clockwise by a given angle around the given axis
+     *
+     * Syntax:
+     *
+     *    math.rotate(w, theta)
+     *    math.rotate(w, theta, v)
+     *
+     * Examples:
+     *
+     *    math.rotate([11, 12], math.pi / 2)                           // returns [-12, 11]
+     *    math.rotate(matrix([11, 12]), math.pi / 2)                   // returns [-12, 11]
+     *
+     *    math.rotate([1, 0, 0], unit('90deg'), [0, 0, 1])             // returns [0, 1, 0]
+     *    math.rotate(matrix([1, 0, 0]), unit('90deg'), [0, 0, 1])     // returns Matrix [0, 1, 0]
+     *
+     *    math.rotate([1, 0], math.complex(1 + i))                     // returns [cos(1 + i) - sin(1 + i), sin(1 + i) + cos(1 + i)]
+     *
+     * See also:
+     *
+     *    matrix, rotationMatrix
+     *
+     * @param {Array | Matrix} w                             Vector to rotate
+     * @param {number | BigNumber | Complex | Unit} theta    Rotation angle
+     * @param {Array | Matrix} [v]                           Rotation axis
+     * @return {Array | Matrix}                              Multiplication of the rotation matrix and w
+     */
+  return typed(name, {
+    'Array , number | BigNumber | Complex | Unit': function ArrayNumberBigNumberComplexUnit(w, theta) {
+      _validateSize(w, 2);
+      var matrixRes = multiply(rotationMatrix(theta), w);
+      return matrixRes.toArray();
+    },
+    'Matrix , number | BigNumber | Complex | Unit': function MatrixNumberBigNumberComplexUnit(w, theta) {
+      _validateSize(w, 2);
+      return multiply(rotationMatrix(theta), w);
+    },
+    'Array, number | BigNumber | Complex | Unit, Array | Matrix': function ArrayNumberBigNumberComplexUnitArrayMatrix(w, theta, v) {
+      _validateSize(w, 3);
+      var matrixRes = multiply(rotationMatrix(theta, v), w);
+      return matrixRes;
+    },
+    'Matrix, number | BigNumber | Complex | Unit, Array | Matrix': function MatrixNumberBigNumberComplexUnitArrayMatrix(w, theta, v) {
+      _validateSize(w, 3);
+      return multiply(rotationMatrix(theta, v), w);
+    }
+  });
+  function _validateSize(v, expectedSize) {
+    var actualSize = Array.isArray(v) ? arraySize(v) : v.size();
+    if (actualSize.length > 2) {
+      throw new RangeError("Vector must be of dimensions 1x".concat(expectedSize));
+    }
+    if (actualSize.length === 2 && actualSize[1] !== 1) {
+      throw new RangeError("Vector must be of dimensions 1x".concat(expectedSize));
+    }
+    if (actualSize[0] !== expectedSize) {
+      throw new RangeError("Vector must be of dimensions 1x".concat(expectedSize));
+    }
+  }
+});

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

@@ -0,0 +1,160 @@
+import { isBigNumber } from '../../utils/is.js';
+import { factory } from '../../utils/factory.js';
+var name = 'rotationMatrix';
+var dependencies = ['typed', 'config', 'multiplyScalar', 'addScalar', 'unaryMinus', 'norm', 'matrix', 'BigNumber', 'DenseMatrix', 'SparseMatrix', 'cos', 'sin'];
+export var createRotationMatrix = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    config,
+    multiplyScalar,
+    addScalar,
+    unaryMinus,
+    norm,
+    BigNumber,
+    matrix,
+    DenseMatrix,
+    SparseMatrix,
+    cos,
+    sin
+  } = _ref;
+  /**
+   * Create a 2-dimensional counter-clockwise rotation matrix (2x2) for a given angle (expressed in radians).
+   * Create a 2-dimensional counter-clockwise rotation matrix (3x3) by a given angle (expressed in radians) around a given axis (1x3).
+   *
+   * Syntax:
+   *
+   *    math.rotationMatrix(theta)
+   *    math.rotationMatrix(theta, format)
+   *    math.rotationMatrix(theta, [v])
+   *    math.rotationMatrix(theta, [v], format)
+   *
+   * Examples:
+   *
+   *    math.rotationMatrix(math.pi / 2)                      // returns [[0, -1], [1, 0]]
+   *    math.rotationMatrix(math.bignumber(1))                // returns [[bignumber(cos(1)), bignumber(-sin(1))], [bignumber(sin(1)), bignumber(cos(1))]]
+   *    math.rotationMatrix(math.complex(1 + i))              // returns [[cos(1 + i), -sin(1 + i)], [sin(1 + i), cos(1 + i)]]
+   *    math.rotationMatrix(math.unit('1rad'))                // returns [[cos(1), -sin(1)], [sin(1), cos(1)]]
+   *
+   *    math.rotationMatrix(math.pi / 2, [0, 1, 0])           // returns [[0, 0, 1], [0, 1, 0], [-1, 0, 0]]
+   *    math.rotationMatrix(math.pi / 2, matrix([0, 1, 0]))   // returns matrix([[0, 0, 1], [0, 1, 0], [-1, 0, 0]])
+   *
+   *
+   * See also:
+   *
+   *    matrix, cos, sin
+   *
+   *
+   * @param {number | BigNumber | Complex | Unit} theta    Rotation angle
+   * @param {Array | Matrix} [v]                           Rotation axis
+   * @param {string} [format]                              Result Matrix storage format
+   * @return {Array | Matrix}                              Rotation matrix
+   */
+
+  return typed(name, {
+    '': function _() {
+      return config.matrix === 'Matrix' ? matrix([]) : [];
+    },
+    string: function string(format) {
+      return matrix(format);
+    },
+    'number | BigNumber | Complex | Unit': function numberBigNumberComplexUnit(theta) {
+      return _rotationMatrix2x2(theta, config.matrix === 'Matrix' ? 'dense' : undefined);
+    },
+    'number | BigNumber | Complex | Unit, string': function numberBigNumberComplexUnitString(theta, format) {
+      return _rotationMatrix2x2(theta, format);
+    },
+    'number | BigNumber | Complex | Unit, Array': function numberBigNumberComplexUnitArray(theta, v) {
+      var matrixV = matrix(v);
+      _validateVector(matrixV);
+      return _rotationMatrix3x3(theta, matrixV, undefined);
+    },
+    'number | BigNumber | Complex | Unit, Matrix': function numberBigNumberComplexUnitMatrix(theta, v) {
+      _validateVector(v);
+      var storageType = v.storage() || (config.matrix === 'Matrix' ? 'dense' : undefined);
+      return _rotationMatrix3x3(theta, v, storageType);
+    },
+    'number | BigNumber | Complex | Unit, Array, string': function numberBigNumberComplexUnitArrayString(theta, v, format) {
+      var matrixV = matrix(v);
+      _validateVector(matrixV);
+      return _rotationMatrix3x3(theta, matrixV, format);
+    },
+    'number | BigNumber | Complex | Unit, Matrix, string': function numberBigNumberComplexUnitMatrixString(theta, v, format) {
+      _validateVector(v);
+      return _rotationMatrix3x3(theta, v, format);
+    }
+  });
+
+  /**
+   * Returns 2x2 matrix of 2D rotation of angle theta
+   *
+   * @param {number | BigNumber | Complex | Unit} theta  The rotation angle
+   * @param {string} format                              The result Matrix storage format
+   * @returns {Matrix}
+   * @private
+   */
+  function _rotationMatrix2x2(theta, format) {
+    var Big = isBigNumber(theta);
+    var minusOne = Big ? new BigNumber(-1) : -1;
+    var cosTheta = cos(theta);
+    var sinTheta = sin(theta);
+    var data = [[cosTheta, multiplyScalar(minusOne, sinTheta)], [sinTheta, cosTheta]];
+    return _convertToFormat(data, format);
+  }
+  function _validateVector(v) {
+    var size = v.size();
+    if (size.length < 1 || size[0] !== 3) {
+      throw new RangeError('Vector must be of dimensions 1x3');
+    }
+  }
+  function _mul(array) {
+    return array.reduce((p, curr) => multiplyScalar(p, curr));
+  }
+  function _convertToFormat(data, format) {
+    if (format) {
+      if (format === 'sparse') {
+        return new SparseMatrix(data);
+      }
+      if (format === 'dense') {
+        return new DenseMatrix(data);
+      }
+      throw new TypeError("Unknown matrix type \"".concat(format, "\""));
+    }
+    return data;
+  }
+
+  /**
+   * Returns a 3x3 matrix of rotation of angle theta around vector v
+   *
+   * @param {number | BigNumber | Complex | Unit} theta The rotation angle
+   * @param {Matrix} v                                  The rotation axis vector
+   * @param {string} format                             The storage format of the resulting matrix
+   * @returns {Matrix}
+   * @private
+   */
+  function _rotationMatrix3x3(theta, v, format) {
+    var normV = norm(v);
+    if (normV === 0) {
+      throw new RangeError('Rotation around zero vector');
+    }
+    var Big = isBigNumber(theta) ? BigNumber : null;
+    var one = Big ? new Big(1) : 1;
+    var minusOne = Big ? new Big(-1) : -1;
+    var vx = Big ? new Big(v.get([0]) / normV) : v.get([0]) / normV;
+    var vy = Big ? new Big(v.get([1]) / normV) : v.get([1]) / normV;
+    var vz = Big ? new Big(v.get([2]) / normV) : v.get([2]) / normV;
+    var c = cos(theta);
+    var oneMinusC = addScalar(one, unaryMinus(c));
+    var s = sin(theta);
+    var r11 = addScalar(c, _mul([vx, vx, oneMinusC]));
+    var r12 = addScalar(_mul([vx, vy, oneMinusC]), _mul([minusOne, vz, s]));
+    var r13 = addScalar(_mul([vx, vz, oneMinusC]), _mul([vy, s]));
+    var r21 = addScalar(_mul([vx, vy, oneMinusC]), _mul([vz, s]));
+    var r22 = addScalar(c, _mul([vy, vy, oneMinusC]));
+    var r23 = addScalar(_mul([vy, vz, oneMinusC]), _mul([minusOne, vx, s]));
+    var r31 = addScalar(_mul([vx, vz, oneMinusC]), _mul([minusOne, vy, s]));
+    var r32 = addScalar(_mul([vy, vz, oneMinusC]), _mul([vx, s]));
+    var r33 = addScalar(c, _mul([vz, vz, oneMinusC]));
+    var data = [[r11, r12, r13], [r21, r22, r23], [r31, r32, r33]];
+    return _convertToFormat(data, format);
+  }
+});

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

@@ -0,0 +1,59 @@
+import { factory } from '../../utils/factory.js';
+import { isMatrix } from '../../utils/is.js';
+import { clone } from '../../utils/object.js';
+import { validateIndex } from '../../utils/array.js';
+var name = 'row';
+var dependencies = ['typed', 'Index', 'matrix', 'range'];
+export var createRow = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    Index,
+    matrix,
+    range
+  } = _ref;
+  /**
+   * Return a row from a Matrix.
+   *
+   * Syntax:
+   *
+   *     math.row(value, index)
+   *
+   * Example:
+   *
+   *     // get a row
+   *     const d = [[1, 2], [3, 4]]
+   *     math.row(d, 1) // returns [[3, 4]]
+   *
+   * See also:
+   *
+   *     column
+   *
+   * @param {Array | Matrix } value   An array or matrix
+   * @param {number} row              The index of the row
+   * @return {Array | Matrix}         The retrieved row
+   */
+  return typed(name, {
+    'Matrix, number': _row,
+    'Array, number': function ArrayNumber(value, row) {
+      return _row(matrix(clone(value)), row).valueOf();
+    }
+  });
+
+  /**
+   * Retrieve a row of a matrix
+   * @param {Matrix } value  A matrix
+   * @param {number} row     The index of the row
+   * @return {Matrix}        The retrieved row
+   */
+  function _row(value, row) {
+    // check dimensions
+    if (value.size().length !== 2) {
+      throw new Error('Only two dimensional matrix is supported');
+    }
+    validateIndex(row, value.size()[0]);
+    var columnRange = range(0, value.size()[1]);
+    var index = new Index(row, columnRange);
+    var result = value.subset(index);
+    return isMatrix(result) ? result : matrix([[result]]);
+  }
+});

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

@@ -0,0 +1,48 @@
+import { arraySize } from '../../utils/array.js';
+import { factory } from '../../utils/factory.js';
+import { noMatrix } from '../../utils/noop.js';
+var name = 'size';
+var dependencies = ['typed', 'config', '?matrix'];
+export var createSize = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    config,
+    matrix
+  } = _ref;
+  /**
+   * Calculate the size of a matrix or scalar.
+   *
+   * Syntax:
+   *
+   *     math.size(x)
+   *
+   * Examples:
+   *
+   *     math.size(2.3)                  // returns []
+   *     math.size('hello world')        // returns [11]
+   *
+   *     const A = [[1, 2, 3], [4, 5, 6]]
+   *     math.size(A)                    // returns [2, 3]
+   *     math.size(math.range(1,6))      // returns [5]
+   *
+   * See also:
+   *
+   *     count, resize, squeeze, subset
+   *
+   * @param {boolean | number | Complex | Unit | string | Array | Matrix} x  A matrix
+   * @return {Array | Matrix} A vector with size of `x`.
+   */
+  return typed(name, {
+    Matrix: function Matrix(x) {
+      return x.create(x.size());
+    },
+    Array: arraySize,
+    string: function string(x) {
+      return config.matrix === 'Array' ? [x.length] : matrix([x.length]);
+    },
+    'number | Complex | BigNumber | Unit | boolean | null': function numberComplexBigNumberUnitBooleanNull(x) {
+      // scalar
+      return config.matrix === 'Array' ? [] : matrix ? matrix([]) : noMatrix();
+    }
+  });
+});

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

@@ -0,0 +1,113 @@
+import { arraySize as size } from '../../utils/array.js';
+import { factory } from '../../utils/factory.js';
+var name = 'sort';
+var dependencies = ['typed', 'matrix', 'compare', 'compareNatural'];
+export var createSort = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    matrix,
+    compare,
+    compareNatural
+  } = _ref;
+  var compareAsc = compare;
+  var compareDesc = (a, b) => -compare(a, b);
+
+  /**
+   * Sort the items in a matrix.
+   *
+   * Syntax:
+   *
+   *    math.sort(x)
+   *    math.sort(x, compare)
+   *
+   * Examples:
+   *
+   *    math.sort([5, 10, 1]) // returns [1, 5, 10]
+   *    math.sort(['C', 'B', 'A', 'D'], math.compareNatural)
+   *    // returns ['A', 'B', 'C', 'D']
+   *
+   *    function sortByLength (a, b) {
+   *      return a.length - b.length
+   *    }
+   *    math.sort(['Langdon', 'Tom', 'Sara'], sortByLength)
+   *    // returns ['Tom', 'Sara', 'Langdon']
+   *
+   * See also:
+   *
+   *    filter, forEach, map, compare, compareNatural
+   *
+   * @param {Matrix | Array} x    A one dimensional matrix or array to sort
+   * @param {Function | 'asc' | 'desc' | 'natural'} [compare='asc']
+   *        An optional _comparator function or name. The function is called as
+   *        `compare(a, b)`, and must return 1 when a > b, -1 when a < b,
+   *        and 0 when a == b.
+   * @return {Matrix | Array} Returns the sorted matrix.
+   */
+  return typed(name, {
+    Array: function Array(x) {
+      _arrayIsVector(x);
+      return x.sort(compareAsc);
+    },
+    Matrix: function Matrix(x) {
+      _matrixIsVector(x);
+      return matrix(x.toArray().sort(compareAsc), x.storage());
+    },
+    'Array, function': function ArrayFunction(x, _comparator) {
+      _arrayIsVector(x);
+      return x.sort(_comparator);
+    },
+    'Matrix, function': function MatrixFunction(x, _comparator) {
+      _matrixIsVector(x);
+      return matrix(x.toArray().sort(_comparator), x.storage());
+    },
+    'Array, string': function ArrayString(x, order) {
+      _arrayIsVector(x);
+      return x.sort(_comparator(order));
+    },
+    'Matrix, string': function MatrixString(x, order) {
+      _matrixIsVector(x);
+      return matrix(x.toArray().sort(_comparator(order)), x.storage());
+    }
+  });
+
+  /**
+   * Get the comparator for given order ('asc', 'desc', 'natural')
+   * @param {'asc' | 'desc' | 'natural'} order
+   * @return {Function} Returns a _comparator function
+   */
+  function _comparator(order) {
+    if (order === 'asc') {
+      return compareAsc;
+    } else if (order === 'desc') {
+      return compareDesc;
+    } else if (order === 'natural') {
+      return compareNatural;
+    } else {
+      throw new Error('String "asc", "desc", or "natural" expected');
+    }
+  }
+
+  /**
+   * Validate whether an array is one dimensional
+   * Throws an error when this is not the case
+   * @param {Array} array
+   * @private
+   */
+  function _arrayIsVector(array) {
+    if (size(array).length !== 1) {
+      throw new Error('One dimensional array expected');
+    }
+  }
+
+  /**
+   * Validate whether a matrix is one dimensional
+   * Throws an error when this is not the case
+   * @param {Matrix} matrix
+   * @private
+   */
+  function _matrixIsVector(matrix) {
+    if (matrix.size().length !== 1) {
+      throw new Error('One dimensional matrix expected');
+    }
+  }
+});