mathjs 14.1.0 → 14.2.0

package/lib/esm/entry/pureFunctionsNumber.generated.js

@@ -5,7 +5,7 @@
 import { config } from './configReadonly.js';
 import { createE, createFalse, createIndex, createInfinity, createLN10, createLOG10E, createMatrix, createNaN, createNull, createPhi, createRangeClass, createReplacer, createResultSet, createSQRT1_2,
 // eslint-disable-line camelcase
-createSubset, createTau, createTyped, createUnaryPlus, createVersion, createXor, createAbs, createAcos, createAcot, createAcsc, createAdd, createAnd, createAsec, createAsin, createAtan, createAtanh, createBigint, createBitNot, createBitXor, createBoolean, createCbrt, createCombinations, createCompare, createCompareText, createCos, createCot, createCsc, createCube, createDivide, createEqualScalar, createErf, createExp, createFilter, createForEach, createFormat, createGamma, createIsInteger, createIsNegative, createIsPositive, createIsZero, createLOG2E, createLargerEq, createLeftShift, createLog, createLog1p, createMap, createMean, createMod, createMultiply, createNot, createNumber, createOr, createPi, createPow, createRandom, createRightLogShift, createSQRT2, createSech, createSin, createSize, createSmallerEq, createSquare, createString, createSubtract, createTanh, createTypeOf, createUnequal, createXgcd, createAcoth, createAddScalar, createAsech, createBitAnd, createCombinationsWithRep, createCosh, createCsch, createDivideScalar, createEqualText, createExpm1, createIsNumeric, createLN2, createLcm, createLog10, createMultiplyScalar, createNthRoot, createPickRandom, createRightArithShift, createSec, createSinh, createSqrt, createTan, createUnaryMinus, createAcosh, createApply, createAsinh, createBitOr, createClone, createCoth, createEqual, createFactorial, createHasNumericValue, createIsNaN, createLarger, createLog2, createMode, createNorm, createPartitionSelect, createPrint, createRandomInt, createRound, createSmaller, createSubtractScalar, createTrue, createVariance, createZeta, createAcsch, createAtan2, createCatalan, createCompareNatural, createComposition, createCumSum, createFloor, createHypot, createLgamma, createMedian, createMultinomial, createPermutations, createQuantileSeq, createSign, createStd, createStirlingS2, createCeil, createDeepEqual, createFix, createIsPrime, createNumeric, createProd, createBellNumbers, createGcd, createMad, createRange, createSum, createCorr, createMax, createMin } from '../factoriesNumber.js';
+createSubset, createTau, createTyped, createUnaryPlus, createVersion, createXor, createAbs, createAcos, createAcot, createAcsc, createAdd, createAnd, createAsec, createAsin, createAtan, createAtanh, createBigint, createBitNot, createBitXor, createBoolean, createCbrt, createCombinations, createCompare, createCompareText, createCos, createCot, createCsc, createCube, createDivide, createEqualScalar, createErf, createExp, createFilter, createForEach, createFormat, createGamma, createIsInteger, createIsNegative, createIsPositive, createIsZero, createLOG2E, createLargerEq, createLeftShift, createLog, createLog1p, createMap, createMean, createMod, createMultiply, createNot, createNumber, createOr, createPi, createPow, createRandom, createRightLogShift, createSQRT2, createSech, createSin, createSize, createSmallerEq, createSquare, createString, createSubtract, createTanh, createTypeOf, createUnequal, createXgcd, createAcoth, createAddScalar, createAsech, createBitAnd, createCombinationsWithRep, createCosh, createCsch, createDivideScalar, createEqualText, createExpm1, createIsNumeric, createLN2, createLcm, createLog10, createMapSlices, createMultiplyScalar, createNthRoot, createPickRandom, createRightArithShift, createSec, createSinh, createSqrt, createTan, createUnaryMinus, createAcosh, createAtan2, createBitOr, createClone, createCoth, createEqual, createFactorial, createHasNumericValue, createIsNaN, createLarger, createLog2, createMode, createNorm, createPartitionSelect, createPrint, createRandomInt, createRound, createSmaller, createSubtractScalar, createTrue, createVariance, createZeta, createAcsch, createCatalan, createCompareNatural, createComposition, createCumSum, createFloor, createHypot, createLgamma, createMedian, createMultinomial, createPermutations, createQuantileSeq, createSign, createStd, createStirlingS2, createAsinh, createCeil, createDeepEqual, createFix, createIsPrime, createNumeric, createProd, createBellNumbers, createGcd, createMad, createRange, createSum, createCorr, createMax, createMin } from '../factoriesNumber.js';
 export var e = /* #__PURE__ */createE({
   config
 });
@@ -286,6 +286,11 @@ export var lcm = /* #__PURE__ */createLcm({
 export var log10 = /* #__PURE__ */createLog10({
   typed
 });
+export var mapSlices = /* #__PURE__ */createMapSlices({
+  isInteger,
+  typed
+});
+export var apply = mapSlices;
 export var multiplyScalar = /* #__PURE__ */createMultiplyScalar({
   typed
 });
@@ -317,11 +322,7 @@ export var unaryMinus = /* #__PURE__ */createUnaryMinus({
 export var acosh = /* #__PURE__ */createAcosh({
   typed
 });
-export var apply = /* #__PURE__ */createApply({
-  isInteger,
-  typed
-});
-export var asinh = /* #__PURE__ */createAsinh({
+export var atan2 = /* #__PURE__ */createAtan2({
   typed
 });
 export var bitOr = /* #__PURE__ */createBitOr({
@@ -390,9 +391,9 @@ export var subtractScalar = /* #__PURE__ */createSubtractScalar({
 export var _true = /* #__PURE__ */createTrue({});
 export var variance = /* #__PURE__ */createVariance({
   add,
-  apply,
   divide,
   isNaN,
+  mapSlices,
   multiply,
   subtract,
   typed
@@ -416,9 +417,6 @@ export var zeta = /* #__PURE__ */createZeta({
 export var acsch = /* #__PURE__ */createAcsch({
   typed
 });
-export var atan2 = /* #__PURE__ */createAtan2({
-  typed
-});
 export var catalan = /* #__PURE__ */createCatalan({
   addScalar,
   combinations,
@@ -490,6 +488,7 @@ export var quantileSeq = /* #__PURE__ */createQuantileSeq({
   divide,
   isInteger,
   larger,
+  mapSlices,
   multiply,
   partitionSelect,
   smaller,
@@ -520,6 +519,9 @@ export var stirlingS2 = /* #__PURE__ */createStirlingS2({
   subtractScalar,
   typed
 });
+export var asinh = /* #__PURE__ */createAsinh({
+  typed
+});
 export var ceil = /* #__PURE__ */createCeil({
   config,
   round,

package/lib/esm/expression/embeddedDocs/embeddedDocs.js

@@ -111,6 +111,7 @@ import { andDocs } from './function/logical/and.js';
 import { notDocs } from './function/logical/not.js';
 import { orDocs } from './function/logical/or.js';
 import { xorDocs } from './function/logical/xor.js';
+import { mapSlicesDocs } from './function/matrix/mapSlices.js';
 import { columnDocs } from './function/matrix/column.js';
 import { concatDocs } from './function/matrix/concat.js';
 import { countDocs } from './function/matrix/count.js';
@@ -572,6 +573,7 @@ export var embeddedDocs = {
   or: orDocs,
   xor: xorDocs,
   // functions - matrix
+  mapSlices: mapSlicesDocs,
   concat: concatDocs,
   count: countDocs,
   cross: crossDocs,

package/lib/esm/expression/embeddedDocs/function/matrix/mapSlices.js

@@ -0,0 +1,11 @@
+export var mapSlicesDocs = {
+  name: 'mapSlices',
+  category: 'Matrix',
+  syntax: ['mapSlices(A, dim, callback)'],
+  description: 'Generate a matrix one dimension less than A by applying callback to ' + 'each slice of A along dimension dim.',
+  examples: ['A = [[1, 2], [3, 4]]', 'mapSlices(A, 1, sum)',
+  // returns [4, 6]
+  'mapSlices(A, 2, product)' // returns [2, 12]
+  ],
+  seealso: ['map', 'forEach']
+};

package/lib/esm/expression/transform/index.transform.js

@@ -1,4 +1,4 @@
-import { isArray, isBigNumber, isMatrix, isNumber, isRange } from '../../utils/is.js';
+import { isArray, isBigInt, isBigNumber, isMatrix, isNumber, isRange } from '../../utils/is.js';
 import { factory } from '../../utils/factory.js';
 var name = 'index';
 var dependencies = ['Index', 'getMatrixDataType'];
@@ -32,14 +32,14 @@ export var createIndexTransform = /* #__PURE__ */factory(name, dependencies, _re
             return v - 1;
           });
         }
-      } else if (isNumber(arg)) {
+      } else if (isNumber(arg) || isBigInt(arg)) {
         arg--;
       } else if (isBigNumber(arg)) {
         arg = arg.toNumber() - 1;
       } else if (typeof arg === 'string') {
         // leave as is
       } else {
-        throw new TypeError('Dimension must be an Array, Matrix, number, string, or Range');
+        throw new TypeError('Dimension must be an Array, Matrix, number, bigint, string, or Range');
       }
       args[i] = arg;
     }

package/lib/esm/expression/transform/mapSlices.transform.js

@@ -0,0 +1,47 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import { errorTransform } from './utils/errorTransform.js';
+import { factory } from '../../utils/factory.js';
+import { createMapSlices } from '../../function/matrix/mapSlices.js';
+import { isBigNumber, isNumber } from '../../utils/is.js';
+var name = 'mapSlices';
+var dependencies = ['typed', 'isInteger'];
+
+/**
+ * Attach a transform function to math.mapSlices
+ * Adds a property transform containing the transform function.
+ *
+ * This transform changed the last `dim` parameter of function mapSlices
+ * from one-based to zero based
+ */
+export var createMapSlicesTransform = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    isInteger
+  } = _ref;
+  var mapSlices = createMapSlices({
+    typed,
+    isInteger
+  });
+
+  // @see: comment of concat itself
+  return typed('mapSlices', {
+    '...any': function any(args) {
+      // change dim from one-based to zero-based
+      var dim = args[1];
+      if (isNumber(dim)) {
+        args[1] = dim - 1;
+      } else if (isBigNumber(dim)) {
+        args[1] = dim.minus(1);
+      }
+      try {
+        return mapSlices.apply(null, args);
+      } catch (err) {
+        throw errorTransform(err);
+      }
+    }
+  });
+}, _objectSpread({
+  isTransformFunction: true
+}, createMapSlices.meta));

package/lib/esm/expression/transform/quantileSeq.transform.js

@@ -2,7 +2,7 @@ import { factory } from '../../utils/factory.js';
 import { createQuantileSeq } from '../../function/statistics/quantileSeq.js';
 import { lastDimToZeroBase } from './utils/lastDimToZeroBase.js';
 var name = 'quantileSeq';
-var dependencies = ['typed', 'bignumber', 'add', 'subtract', 'divide', 'multiply', 'partitionSelect', 'compare', 'isInteger', 'smaller', 'smallerEq', 'larger'];
+var dependencies = ['typed', 'bignumber', 'add', 'subtract', 'divide', 'multiply', 'partitionSelect', 'compare', 'isInteger', 'smaller', 'smallerEq', 'larger', 'mapSlices'];
 
 /**
  * Attach a transform function to math.quantileSeq
@@ -24,7 +24,8 @@ export var createQuantileSeqTransform = /* #__PURE__ */factory(name, dependencie
     isInteger,
     smaller,
     smallerEq,
-    larger
+    larger,
+    mapSlices
   } = _ref;
   var quantileSeq = createQuantileSeq({
     typed,
@@ -38,7 +39,8 @@ export var createQuantileSeqTransform = /* #__PURE__ */factory(name, dependencie
     isInteger,
     smaller,
     smallerEq,
-    larger
+    larger,
+    mapSlices
   });
   return typed('quantileSeq', {
     'Array | Matrix, number | BigNumber': quantileSeq,

package/lib/esm/expression/transform/variance.transform.js

@@ -3,7 +3,7 @@ import { errorTransform } from './utils/errorTransform.js';
 import { createVariance } from '../../function/statistics/variance.js';
 import { lastDimToZeroBase } from './utils/lastDimToZeroBase.js';
 var name = 'variance';
-var dependencies = ['typed', 'add', 'subtract', 'multiply', 'divide', 'apply', 'isNaN'];
+var dependencies = ['typed', 'add', 'subtract', 'multiply', 'divide', 'mapSlices', 'isNaN'];
 
 /**
  * Attach a transform function to math.var
@@ -19,7 +19,7 @@ export var createVarianceTransform = /* #__PURE__ */factory(name, dependencies,
     subtract,
     multiply,
     divide,
-    apply,
+    mapSlices,
     isNaN
   } = _ref;
   var variance = createVariance({
@@ -28,7 +28,7 @@ export var createVarianceTransform = /* #__PURE__ */factory(name, dependencies,
     subtract,
     multiply,
     divide,
-    apply,
+    mapSlices,
     isNaN
   });
   return typed(name, {

package/lib/esm/factoriesAny.js

@@ -32,7 +32,7 @@ export { createSplitUnit } from './type/unit/function/splitUnit.js';
 export { createUnaryMinus } from './function/arithmetic/unaryMinus.js';
 export { createUnaryPlus } from './function/arithmetic/unaryPlus.js';
 export { createAbs } from './function/arithmetic/abs.js';
-export { createApply } from './function/matrix/apply.js';
+export { createMapSlices } from './function/matrix/mapSlices.js';
 export { createAddScalar } from './function/arithmetic/addScalar.js';
 export { createSubtractScalar } from './function/arithmetic/subtractScalar.js';
 export { createCbrt } from './function/arithmetic/cbrt.js';
@@ -271,7 +271,7 @@ export { createE, createUppercaseE, createFalse, createI, createInfinity, create
 // eslint-disable-line camelcase
 createSQRT2, createTau, createTrue, createVersion } from './constants.js';
 export { createAtomicMass, createAvogadro, createBohrMagneton, createBohrRadius, createBoltzmann, createClassicalElectronRadius, createConductanceQuantum, createCoulomb, createDeuteronMass, createEfimovFactor, createElectricConstant, createElectronMass, createElementaryCharge, createFaraday, createFermiCoupling, createFineStructure, createFirstRadiation, createGasConstant, createGravitationConstant, createGravity, createHartreeEnergy, createInverseConductanceQuantum, createKlitzing, createLoschmidt, createMagneticConstant, createMagneticFluxQuantum, createMolarMass, createMolarMassC12, createMolarPlanckConstant, createMolarVolume, createNeutronMass, createNuclearMagneton, createPlanckCharge, createPlanckConstant, createPlanckLength, createPlanckMass, createPlanckTemperature, createPlanckTime, createProtonMass, createQuantumOfCirculation, createReducedPlanckConstant, createRydberg, createSackurTetrode, createSecondRadiation, createSpeedOfLight, createStefanBoltzmann, createThomsonCrossSection, createVacuumImpedance, createWeakMixingAngle, createWienDisplacement } from './type/unit/physicalConstants.js';
-export { createApplyTransform } from './expression/transform/apply.transform.js';
+export { createMapSlicesTransform } from './expression/transform/mapSlices.transform.js';
 export { createColumnTransform } from './expression/transform/column.transform.js';
 export { createFilterTransform } from './expression/transform/filter.transform.js';
 export { createForEachTransform } from './expression/transform/forEach.transform.js';

package/lib/esm/factoriesNumber.js

@@ -121,7 +121,7 @@ export var createOr = /* #__PURE__ */createNumberFactory('or', orNumber);
 export var createXor = /* #__PURE__ */createNumberFactory('xor', xorNumber);
 
 // matrix
-export { createApply } from './function/matrix/apply.js';
+export { createMapSlices } from './function/matrix/mapSlices.js';
 export { createFilter } from './function/matrix/filter.js';
 export { createForEach } from './function/matrix/forEach.js';
 export { createMap } from './function/matrix/map.js';
@@ -211,7 +211,7 @@ export var createTan = /* #__PURE__ */createNumberFactory('tan', tanNumber);
 export var createTanh = /* #__PURE__ */createNumberFactory('tanh', tanhNumber);
 
 // transforms
-export { createApplyTransform } from './expression/transform/apply.transform.js';
+export { createMapSlicesTransform } from './expression/transform/mapSlices.transform.js';
 export { createFilterTransform } from './expression/transform/filter.transform.js';
 export { createForEachTransform } from './expression/transform/forEach.transform.js';
 export { createMapTransform } from './expression/transform/map.transform.js';

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

@@ -1,36 +1,41 @@
 import Decimal from 'decimal.js';
 import { factory } from '../../utils/factory.js';
 import { deepMap } from '../../utils/collection.js';
-import { nearlyEqual } from '../../utils/number.js';
+import { isInteger, nearlyEqual } from '../../utils/number.js';
 import { nearlyEqual as bigNearlyEqual } from '../../utils/bignumber/nearlyEqual.js';
 import { createMatAlgo11xS0s } from '../../type/matrix/utils/matAlgo11xS0s.js';
 import { createMatAlgo12xSfs } from '../../type/matrix/utils/matAlgo12xSfs.js';
 import { createMatAlgo14xDs } from '../../type/matrix/utils/matAlgo14xDs.js';
 var name = 'ceil';
 var dependencies = ['typed', 'config', 'round', 'matrix', 'equalScalar', 'zeros', 'DenseMatrix'];
+var bigTen = new Decimal(10);
 export var createCeilNumber = /* #__PURE__ */factory(name, ['typed', 'config', 'round'], _ref => {
   var {
     typed,
     config,
     round
   } = _ref;
+  function _ceilNumber(x) {
+    // See ./floor.js _floorNumber for rationale here
+    var c = Math.ceil(x);
+    var r = round(x);
+    if (c === r) return c;
+    if (nearlyEqual(x, r, config.relTol, config.absTol) && !nearlyEqual(x, c, config.relTol, config.absTol)) {
+      return r;
+    }
+    return c;
+  }
   return typed(name, {
-    number: function number(x) {
-      if (nearlyEqual(x, round(x), config.relTol, config.absTol)) {
-        return round(x);
-      } else {
-        return Math.ceil(x);
-      }
-    },
+    number: _ceilNumber,
     'number, number': function number_number(x, n) {
-      if (nearlyEqual(x, round(x, n), config.relTol, config.absTol)) {
-        return round(x, n);
-      } else {
-        var [number, exponent] = "".concat(x, "e").split('e');
-        var result = Math.ceil(Number("".concat(number, "e").concat(Number(exponent) + n)));
-        [number, exponent] = "".concat(result, "e").split('e');
-        return Number("".concat(number, "e").concat(Number(exponent) - n));
+      if (!isInteger(n)) {
+        throw new RangeError('number of decimals in function ceil must be an integer');
+      }
+      if (n < 0 || n > 15) {
+        throw new RangeError('number of decimals in ceil number must be in range 0-15');
       }
+      var shift = 10 ** n;
+      return _ceilNumber(x * shift) / shift;
     }
   });
 });
@@ -60,6 +65,15 @@ export var createCeil = /* #__PURE__ */factory(name, dependencies, _ref2 => {
     config,
     round
   });
+  function _bigCeil(x) {
+    // see ./floor.js _floorNumber for rationale
+    var bne = (a, b) => bigNearlyEqual(a, b, config.relTol, config.absTol);
+    var c = x.ceil();
+    var r = round(x);
+    if (c.eq(r)) return c;
+    if (bne(x, r) && !bne(x, c)) return r;
+    return c;
+  }
   /**
    * Round a value towards plus infinity
    * If `x` is complex, both real and imaginary part are rounded towards plus infinity.
@@ -118,20 +132,14 @@ export var createCeil = /* #__PURE__ */factory(name, dependencies, _ref2 => {
     'Complex, BigNumber': function Complex_BigNumber(x, n) {
       return x.ceil(n.toNumber());
     },
-    BigNumber: function BigNumber(x) {
-      if (bigNearlyEqual(x, round(x), config.relTol, config.absTol)) {
-        return round(x);
-      } else {
-        return x.ceil();
-      }
-    },
+    BigNumber: _bigCeil,
     'BigNumber, BigNumber': function BigNumber_BigNumber(x, n) {
-      if (bigNearlyEqual(x, round(x, n), config.relTol, config.absTol)) {
-        return round(x, n);
-      } else {
-        return x.toDecimalPlaces(n.toNumber(), Decimal.ROUND_CEIL);
-      }
+      var shift = bigTen.pow(n);
+      return _bigCeil(x.mul(shift)).div(shift);
     },
+    bigint: b => b,
+    'bigint, number': (b, _dummy) => b,
+    'bigint, BigNumber': (b, _dummy) => b,
     Fraction: function Fraction(x) {
       return x.ceil();
     },

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

@@ -106,6 +106,9 @@ export var createFix = /* #__PURE__ */factory(name, dependencies, _ref2 => {
     'BigNumber, number | BigNumber': function BigNumber_number__BigNumber(x, n) {
       return x.isNegative() ? ceil(x, n) : floor(x, n);
     },
+    bigint: b => b,
+    'bigint, number': (b, _dummy) => b,
+    'bigint, BigNumber': (b, _dummy) => b,
     Fraction: function Fraction(x) {
       return x.s < 0n ? x.ceil() : x.floor();
     },

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

@@ -1,36 +1,48 @@
 import Decimal from 'decimal.js';
 import { factory } from '../../utils/factory.js';
 import { deepMap } from '../../utils/collection.js';
-import { nearlyEqual } from '../../utils/number.js';
+import { isInteger, nearlyEqual } from '../../utils/number.js';
 import { nearlyEqual as bigNearlyEqual } from '../../utils/bignumber/nearlyEqual.js';
 import { createMatAlgo11xS0s } from '../../type/matrix/utils/matAlgo11xS0s.js';
 import { createMatAlgo12xSfs } from '../../type/matrix/utils/matAlgo12xSfs.js';
 import { createMatAlgo14xDs } from '../../type/matrix/utils/matAlgo14xDs.js';
 var name = 'floor';
 var dependencies = ['typed', 'config', 'round', 'matrix', 'equalScalar', 'zeros', 'DenseMatrix'];
+var bigTen = new Decimal(10);
 export var createFloorNumber = /* #__PURE__ */factory(name, ['typed', 'config', 'round'], _ref => {
   var {
     typed,
     config,
     round
   } = _ref;
+  function _floorNumber(x) {
+    // First, if the floor and the round are identical we can be
+    // quite comfortable that is the best answer:
+    var f = Math.floor(x);
+    var r = round(x);
+    if (f === r) return f;
+    // OK, they are different. If x is truly distinct from f but
+    // appears indistinguishable from r, presume it really is just
+    // the integer r with rounding/computation error, and return that
+    if (nearlyEqual(x, r, config.relTol, config.absTol) && !nearlyEqual(x, f, config.relTol, config.absTol)) {
+      return r;
+    }
+    // Otherwise (x distinct from both r and f, or indistinguishable from
+    // both r and f) may as well just return f, as that's the best
+    // candidate we can discern:
+    return f;
+  }
   return typed(name, {
-    number: function number(x) {
-      if (nearlyEqual(x, round(x), config.relTol, config.absTol)) {
-        return round(x);
-      } else {
-        return Math.floor(x);
-      }
-    },
+    number: _floorNumber,
     'number, number': function number_number(x, n) {
-      if (nearlyEqual(x, round(x, n), config.relTol, config.absTol)) {
-        return round(x, n);
-      } else {
-        var [number, exponent] = "".concat(x, "e").split('e');
-        var result = Math.floor(Number("".concat(number, "e").concat(Number(exponent) + n)));
-        [number, exponent] = "".concat(result, "e").split('e');
-        return Number("".concat(number, "e").concat(Number(exponent) - n));
+      if (!isInteger(n)) {
+        throw new RangeError('number of decimals in function floor must be an integer');
+      }
+      if (n < 0 || n > 15) {
+        throw new RangeError('number of decimals in floor number must be in range 0 - 15');
       }
+      var shift = 10 ** n;
+      return _floorNumber(x * shift) / shift;
     }
   });
 });
@@ -60,6 +72,15 @@ export var createFloor = /* #__PURE__ */factory(name, dependencies, _ref2 => {
     config,
     round
   });
+  function _bigFloor(x) {
+    // see _floorNumber above for rationale
+    var bne = (a, b) => bigNearlyEqual(a, b, config.relTol, config.absTol);
+    var f = x.floor();
+    var r = round(x);
+    if (f.eq(r)) return f;
+    if (bne(x, r) && !bne(x, f)) return r;
+    return f;
+  }
   /**
    * Round a value towards minus infinity.
    * For matrices, the function is evaluated element wise.
@@ -121,20 +142,14 @@ export var createFloor = /* #__PURE__ */factory(name, dependencies, _ref2 => {
     'Complex, BigNumber': function Complex_BigNumber(x, n) {
       return x.floor(n.toNumber());
     },
-    BigNumber: function BigNumber(x) {
-      if (bigNearlyEqual(x, round(x), config.relTol, config.absTol)) {
-        return round(x);
-      } else {
-        return x.floor();
-      }
-    },
+    BigNumber: _bigFloor,
     'BigNumber, BigNumber': function BigNumber_BigNumber(x, n) {
-      if (bigNearlyEqual(x, round(x, n), config.relTol, config.absTol)) {
-        return round(x, n);
-      } else {
-        return x.toDecimalPlaces(n.toNumber(), Decimal.ROUND_FLOOR);
-      }
+      var shift = bigTen.pow(n);
+      return _bigFloor(x.mul(shift)).div(shift);
     },
+    bigint: b => b,
+    'bigint, number': (b, _dummy) => b,
+    'bigint, BigNumber': (b, _dummy) => b,
     Fraction: function Fraction(x) {
       return x.floor();
     },

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

@@ -137,6 +137,10 @@ export var createRound = /* #__PURE__ */factory(name, dependencies, _ref => {
       var xSelected = bigNearlyEqual(x, xEpsilon, config.relTol, config.absTol) ? xEpsilon : x;
       return xSelected.toDecimalPlaces(n.toNumber());
     },
+    // bigints can't be rounded
+    bigint: b => b,
+    'bigint, number': (b, _dummy) => b,
+    'bigint, BigNumber': (b, _dummy) => b,
     Fraction: function Fraction(x) {
       return x.round();
     },

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

@@ -20,7 +20,7 @@ export var createCtranspose = /* #__PURE__ */factory(name, dependencies, _ref =>
    * Examples:
    *
    *     const A = [[1, 2, 3], [4, 5, math.complex(6,7)]]
-   *     math.ctranspose(A)               // returns [[1, 4], [2, 5], [3, {re:6,im:7}]]
+   *     math.ctranspose(A)      // returns [[1, 4], [2, 5], [3, {re:6,im:-7}]]
    *
    * See also:
    *

package/lib/esm/function/matrix/{apply.js → mapSlices.js}

@@ -2,9 +2,9 @@ import { factory } from '../../utils/factory.js';
 import { arraySize } from '../../utils/array.js';
 import { isMatrix } from '../../utils/is.js';
 import { IndexError } from '../../error/IndexError.js';
-var name = 'apply';
+var name = 'mapSlices';
 var dependencies = ['typed', 'isInteger'];
-export var createApply = /* #__PURE__ */factory(name, dependencies, _ref => {
+export var createMapSlices = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     isInteger
@@ -16,7 +16,7 @@ export var createApply = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    * Syntax:
    *
-   *     math.apply(A, dim, callback)
+   *     math.mapSlices(A, dim, callback)
    *
    * Where:
    *
@@ -27,19 +27,24 @@ export var createApply = /* #__PURE__ */factory(name, dependencies, _ref => {
    *    const A = [[1, 2], [3, 4]]
    *    const sum = math.sum
    *
-   *    math.apply(A, 0, sum)             // returns [4, 6]
-   *    math.apply(A, 1, sum)             // returns [3, 7]
+   *    math.mapSlices(A, 0, sum)             // returns [4, 6]
+   *    math.mapSlices(A, 1, sum)             // returns [3, 7]
    *
    * See also:
    *
    *    map, filter, forEach
    *
+   * Note:
+   *
+   *    `mapSlices()` is also currently available via its deprecated
+   *    synonym `apply()`.
+   *
    * @param {Array | Matrix} array   The input Matrix
    * @param {number} dim             The dimension along which the callback is applied
    * @param {Function} callback      The callback function that is applied. This Function
    *                                 should take an array or 1-d matrix as an input and
    *                                 return a number.
-   * @return {Array | Matrix} res    The residual matrix with the function applied over some dimension.
+   * @return {Array | Matrix} res    The residual matrix with the function mapped on the slices over some dimension.
    */
   return typed(name, {
     'Array | Matrix, number | BigNumber, function': function Array__Matrix_number__BigNumber_function(mat, dim, callback) {
@@ -51,12 +56,14 @@ export var createApply = /* #__PURE__ */factory(name, dependencies, _ref => {
         throw new IndexError(dim, size.length);
       }
       if (isMatrix(mat)) {
-        return mat.create(_apply(mat.valueOf(), dim, callback), mat.datatype());
+        return mat.create(_mapSlices(mat.valueOf(), dim, callback), mat.datatype());
       } else {
-        return _apply(mat, dim, callback);
+        return _mapSlices(mat, dim, callback);
       }
     }
   });
+}, {
+  formerly: 'apply'
 });
 
 /**
@@ -67,7 +74,7 @@ export var createApply = /* #__PURE__ */factory(name, dependencies, _ref => {
  * @returns {Array} ret
  * @private
  */
-function _apply(mat, dim, callback) {
+function _mapSlices(mat, dim, callback) {
   var i, ret, tran;
   if (dim <= 0) {
     if (!Array.isArray(mat[0])) {
@@ -76,14 +83,14 @@ function _apply(mat, dim, callback) {
       tran = _switch(mat);
       ret = [];
       for (i = 0; i < tran.length; i++) {
-        ret[i] = _apply(tran[i], dim - 1, callback);
+        ret[i] = _mapSlices(tran[i], dim - 1, callback);
       }
       return ret;
     }
   } else {
     ret = [];
     for (i = 0; i < mat.length; i++) {
-      ret[i] = _apply(mat[i], dim - 1, callback);
+      ret[i] = _mapSlices(mat[i], dim - 1, callback);
     }
     return ret;
   }