mathjs 14.0.1 → 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, createRandomInt, createRightArithShift, createSec, createSinh, createSqrt, createTan, createUnaryMinus, createAcosh, createApply, createAsinh, createBitOr, createClone, createCoth, createEqual, createFactorial, createHasNumericValue, createIsNaN, createLarger, createLog2, createMode, createNorm, createPartitionSelect, createPrint, 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
 });
@@ -296,10 +301,6 @@ export var pickRandom = /* #__PURE__ */createPickRandom({
   config,
   typed
 });
-export var randomInt = /* #__PURE__ */createRandomInt({
-  config,
-  typed
-});
 export var rightArithShift = /* #__PURE__ */createRightArithShift({
   typed
 });
@@ -321,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({
@@ -376,6 +373,11 @@ export var partitionSelect = /* #__PURE__ */createPartitionSelect({
 export var print = /* #__PURE__ */createPrint({
   typed
 });
+export var randomInt = /* #__PURE__ */createRandomInt({
+  config,
+  log2,
+  typed
+});
 export var round = /* #__PURE__ */createRound({
   typed
 });
@@ -389,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
@@ -415,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,
@@ -489,6 +488,7 @@ export var quantileSeq = /* #__PURE__ */createQuantileSeq({
   divide,
   isInteger,
   larger,
+  mapSlices,
   multiply,
   partitionSelect,
   smaller,
@@ -519,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/arithmetic/sign.js

@@ -2,7 +2,7 @@ export var signDocs = {
   name: 'sign',
   category: 'Arithmetic',
   syntax: ['sign(x)'],
-  description: 'Compute the sign of a value. The sign of a value x is 1 when x>1, -1 when x<0, and 0 when x=0.',
+  description: 'Compute the sign of a value. The sign of a value x is 1 when x>0, -1 when x<0, and 0 when x=0.',
   examples: ['sign(3.5)', 'sign(-4.2)', 'sign(0)'],
   seealso: ['abs']
 };

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/log.js

@@ -1,7 +1,9 @@
 import { factory } from '../../utils/factory.js';
+import { promoteLogarithm } from '../../utils/bigint.js';
 import { logNumber } from '../../plain/number/index.js';
 var name = 'log';
 var dependencies = ['config', 'typed', 'typeOf', 'divideScalar', 'Complex'];
+var nlg16 = Math.log(16);
 export var createLog = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
@@ -45,24 +47,29 @@ export var createLog = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @return {number | BigNumber | Fraction | Complex}
    *            Returns the logarithm of `x`
    */
+  function complexLog(c) {
+    return c.log();
+  }
+  function complexLogNumber(x) {
+    return complexLog(new Complex(x, 0));
+  }
   return typed(name, {
     number: function number(x) {
       if (x >= 0 || config.predictable) {
         return logNumber(x);
       } else {
         // negative value -> complex value computation
-        return new Complex(x, 0).log();
+        return complexLogNumber(x);
       }
     },
-    Complex: function Complex(x) {
-      return x.log();
-    },
+    bigint: promoteLogarithm(nlg16, logNumber, config, complexLogNumber),
+    Complex: complexLog,
     BigNumber: function BigNumber(x) {
       if (!x.isNegative() || config.predictable) {
         return x.ln();
       } else {
         // downgrade to number, return Complex valued result
-        return new Complex(x.toNumber(), 0).log();
+        return complexLogNumber(x.toNumber());
       }
     },
     'any, any': typed.referToSelf(self => (x, base) => {

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

@@ -1,13 +1,15 @@
-import { factory } from '../../utils/factory.js';
-import { deepMap } from '../../utils/collection.js';
 import { log10Number } from '../../plain/number/index.js';
+import { promoteLogarithm } from '../../utils/bigint.js';
+import { deepMap } from '../../utils/collection.js';
+import { factory } from '../../utils/factory.js';
 var name = 'log10';
 var dependencies = ['typed', 'config', 'Complex'];
+var log16 = log10Number(16);
 export var createLog10 = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     config,
-    Complex: _Complex
+    Complex
   } = _ref;
   /**
    * Calculate the 10-base logarithm of a value. This is the same as calculating `log(x, 10)`.
@@ -34,24 +36,30 @@ export var createLog10 = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @return {number | BigNumber | Complex | Array | Matrix}
    *            Returns the 10-base logarithm of `x`
    */
+
+  function complexLog(c) {
+    return c.log().div(Math.LN10);
+  }
+  function complexLogNumber(x) {
+    return complexLog(new Complex(x, 0));
+  }
   return typed(name, {
     number: function number(x) {
       if (x >= 0 || config.predictable) {
         return log10Number(x);
       } else {
         // negative value -> complex value computation
-        return new _Complex(x, 0).log().div(Math.LN10);
+        return complexLogNumber(x);
       }
     },
-    Complex: function Complex(x) {
-      return new _Complex(x).log().div(Math.LN10);
-    },
+    bigint: promoteLogarithm(log16, log10Number, config, complexLogNumber),
+    Complex: complexLog,
     BigNumber: function BigNumber(x) {
       if (!x.isNegative() || config.predictable) {
         return x.log();
       } else {
         // downgrade to number, return Complex valued result
-        return new _Complex(x.toNumber(), 0).log().div(Math.LN10);
+        return complexLogNumber(x.toNumber());
       }
     },
     'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))