mathjs 14.5.3 → 14.7.0

package/lib/esm/entry/dependenciesAny/dependenciesUnitClass.generated.js

@@ -17,6 +17,7 @@ import { numberDependencies } from './dependenciesNumber.generated.js';
 import { powDependencies } from './dependenciesPow.generated.js';
 import { roundDependencies } from './dependenciesRound.generated.js';
 import { subtractScalarDependencies } from './dependenciesSubtractScalar.generated.js';
+import { toBestDependencies } from './dependenciesToBest.generated.js';
 import { createUnitClass } from '../../factoriesAny.js';
 export var UnitDependencies = {
   BigNumberDependencies,
@@ -34,5 +35,6 @@ export var UnitDependencies = {
   powDependencies,
   roundDependencies,
   subtractScalarDependencies,
+  toBestDependencies,
   createUnitClass
 };

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

@@ -340,6 +340,7 @@ export { tanhDependencies } from './dependenciesAny/dependenciesTanh.generated.j
 export { tauDependencies } from './dependenciesAny/dependenciesTau.generated.js';
 export { thomsonCrossSectionDependencies } from './dependenciesAny/dependenciesThomsonCrossSection.generated.js';
 export { toDependencies } from './dependenciesAny/dependenciesTo.generated.js';
+export { toBestDependencies } from './dependenciesAny/dependenciesToBest.generated.js';
 export { traceDependencies } from './dependenciesAny/dependenciesTrace.generated.js';
 export { transposeDependencies } from './dependenciesAny/dependenciesTranspose.generated.js';
 export { trueDependencies } from './dependenciesAny/dependenciesTrue.generated.js';

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

@@ -7,7 +7,7 @@ import { config } from './configReadonly.js';
 import { createNode, createObjectNode, createOperatorNode, createParenthesisNode, createRelationalNode, createArrayNode, createBlockNode, createConditionalNode, createConstantNode, createRangeNode, createReviver, createChainClass, createFunctionAssignmentNode, createChain, createAccessorNode, createAssignmentNode, createIndexNode, createSymbolNode, createFunctionNode, createParse, createResolve, createSimplifyConstant, createCompile, createSimplifyCore, createEvaluate, createHelpClass, createParserClass, createSimplify, createSymbolicEqual, createLeafCount, createParser, createRationalize, createDerivative, createHelp, createMapSlicesTransform, createFilterTransform, createForEachTransform, createMapTransform, createOrTransform, createAndTransform, createConcatTransform, createIndexTransform, createPrintTransform, createSumTransform, createBitAndTransform, createMinTransform, createSubsetTransform, createBitOrTransform, createCumSumTransform, createDiffTransform, createMaxTransform, createRangeTransform, createRowTransform, createColumnTransform, createMeanTransform, createQuantileSeqTransform, createVarianceTransform, createStdTransform } from '../factoriesAny.js';
 import { BigNumber, Complex, e, _false, fineStructure, Fraction, i, _Infinity, LN10, LOG10E, Matrix, _NaN, _null, phi, Range, ResultSet, SQRT1_2,
 // eslint-disable-line camelcase
-sackurTetrode, tau, _true, version, DenseMatrix, efimovFactor, LN2, pi, replacer, SQRT2, typed, weakMixingAngle, abs, acos, acot, acsc, addScalar, arg, asech, asinh, atan, atanh, bigint, bitNot, boolean, clone, combinations, complex, conj, cos, cot, csc, cube, equalScalar, erf, exp, expm1, filter, flatten, forEach, format, getMatrixDataType, hex, im, isInteger, isNegative, isPositive, isZero, LOG2E, lgamma, log10, log2, map, multiplyScalar, not, number, oct, pickRandom, print, random, re, sec, sign, sin, SparseMatrix, splitUnit, square, string, subtractScalar, tan, typeOf, acosh, acsch, asec, bignumber, combinationsWithRep, cosh, csch, isNaN, isPrime, mapSlices, matrix, matrixFromFunction, ones, randomInt, reshape, sech, sinh, sparse, sqrt, squeeze, tanh, transpose, xgcd, zeros, acoth, asin, bin, concat, coth, ctranspose, diag, dotMultiply, equal, fraction, identity, isNumeric, kron, largerEq, leftShift, mode, nthRoot, numeric, prod, resize, rightArithShift, round, size, smaller, to, unaryMinus, unequal, xor, add, atan2, bitAnd, bitOr, bitXor, cbrt, compare, compareText, count, deepEqual, divideScalar, dotDivide, equalText, floor, gcd, hasNumericValue, hypot, ImmutableDenseMatrix, Index, larger, log, lsolve, matrixFromColumns, max, min, mod, nthRoots, or, partitionSelect, qr, rightLogShift, smallerEq, subset, subtract, trace, usolve, catalan, compareNatural, composition, diff, distance, dot, FibonacciHeap, index, invmod, lcm, log1p, lsolveAll, matrixFromRows, multiply, range, row, setCartesian, setDistinct, setIsSubset, setPowerset, slu, sort, unaryPlus, usolveAll, zpk2tf, and, ceil, column, cross, det, fix, inv, pinv, pow, setDifference, setMultiplicity, setSymDifference, Spa, sqrtm, sum, Unit, vacuumImpedance, wienDisplacement, atomicMass, bohrMagneton, boltzmann, conductanceQuantum, coulomb, createUnit, deuteronMass, dotPow, electricConstant, elementaryCharge, expm, faraday, fft, gamma, gravitationConstant, hartreeEnergy, ifft, inverseConductanceQuantum, klitzing, loschmidt, magneticConstant, molarMass, molarPlanckConstant, neutronMass, nuclearMagneton, planckCharge, planckLength, planckTemperature, protonMass, quantumOfCirculation, reducedPlanckConstant, rydberg, secondRadiation, setSize, speedOfLight, stefanBoltzmann, thomsonCrossSection, avogadro, bohrRadius, coulombConstant, divide, electronMass, factorial, firstRadiation, gravity, intersect, lup, magneticFluxQuantum, molarMassC12, multinomial, permutations, planckMass, polynomialRoot, setIntersect, solveODE, stirlingS2, unit, bellNumbers, cumsum, eigs, fermiCoupling, gasConstant, kldivergence, lusolve, mean, molarVolume, planckConstant, quantileSeq, setUnion, variance, classicalElectronRadius, median, corr, freqz, mad, std, zeta, norm, rotationMatrix, planckTime, schur, rotate, sylvester, lyap } from './pureFunctionsAny.generated.js';
+sackurTetrode, tau, _true, version, DenseMatrix, efimovFactor, LN2, pi, replacer, SQRT2, typed, weakMixingAngle, abs, acos, acot, acsc, addScalar, arg, asech, asinh, atan, atanh, bigint, bitNot, boolean, clone, combinations, complex, conj, cos, cot, csc, cube, equalScalar, erf, exp, expm1, filter, flatten, forEach, format, getMatrixDataType, hex, im, isInteger, isNegative, isPositive, isZero, LOG2E, lgamma, log10, log2, map, multiplyScalar, not, number, oct, pickRandom, print, random, re, sec, sign, sin, SparseMatrix, splitUnit, square, string, subtractScalar, tan, toBest, typeOf, acosh, acsch, asec, bignumber, combinationsWithRep, cosh, csch, isNaN, isPrime, mapSlices, matrix, matrixFromFunction, ones, randomInt, reshape, sech, sinh, sparse, sqrt, squeeze, tanh, transpose, xgcd, zeros, acoth, asin, bin, concat, coth, ctranspose, diag, dotMultiply, equal, fraction, identity, isNumeric, kron, largerEq, leftShift, mode, nthRoot, numeric, prod, resize, rightArithShift, round, size, smaller, to, unaryMinus, unequal, xor, add, atan2, bitAnd, bitOr, bitXor, cbrt, compare, compareText, count, deepEqual, divideScalar, dotDivide, equalText, floor, gcd, hasNumericValue, hypot, ImmutableDenseMatrix, Index, larger, log, lsolve, matrixFromColumns, max, min, mod, nthRoots, or, partitionSelect, qr, rightLogShift, smallerEq, subset, subtract, trace, usolve, catalan, compareNatural, composition, diff, distance, dot, FibonacciHeap, index, invmod, lcm, log1p, lsolveAll, matrixFromRows, multiply, range, row, setCartesian, setDistinct, setIsSubset, setPowerset, slu, sort, unaryPlus, usolveAll, zpk2tf, and, ceil, column, cross, det, fix, inv, pinv, pow, setDifference, setMultiplicity, setSymDifference, Spa, sqrtm, sum, Unit, vacuumImpedance, wienDisplacement, atomicMass, bohrMagneton, boltzmann, conductanceQuantum, coulomb, createUnit, deuteronMass, dotPow, electricConstant, elementaryCharge, expm, faraday, fft, gamma, gravitationConstant, hartreeEnergy, ifft, inverseConductanceQuantum, klitzing, loschmidt, magneticConstant, molarMass, molarPlanckConstant, neutronMass, nuclearMagneton, planckCharge, planckLength, planckTemperature, protonMass, quantumOfCirculation, reducedPlanckConstant, rydberg, secondRadiation, setSize, speedOfLight, stefanBoltzmann, thomsonCrossSection, avogadro, bohrRadius, coulombConstant, divide, electronMass, factorial, firstRadiation, gravity, intersect, lup, magneticFluxQuantum, molarMassC12, multinomial, permutations, planckMass, polynomialRoot, setIntersect, solveODE, stirlingS2, unit, bellNumbers, cumsum, eigs, fermiCoupling, gasConstant, kldivergence, lusolve, mean, molarVolume, planckConstant, quantileSeq, setUnion, variance, classicalElectronRadius, median, corr, freqz, mad, std, zeta, norm, rotationMatrix, planckTime, schur, rotate, sylvester, lyap } from './pureFunctionsAny.generated.js';
 var math = {}; // NOT pure!
 var mathWithTransform = {}; // NOT pure!
 var classes = {}; // NOT pure!
@@ -322,6 +322,7 @@ _extends(math, {
   string,
   subtractScalar,
   tan,
+  toBest,
   typeOf,
   acosh,
   acsch,

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

@@ -5,7 +5,7 @@
 import { config } from './configReadonly.js';
 import { createBigNumberClass, createComplexClass, createE, createFalse, createFineStructure, createFractionClass, createI, createInfinity, createLN10, createLOG10E, createMatrixClass, createNaN, createNull, createPhi, createRangeClass, createResultSet, createSQRT1_2,
 // eslint-disable-line camelcase
-createSackurTetrode, createTau, createTrue, createVersion, createDenseMatrixClass, createEfimovFactor, createLN2, createPi, createReplacer, createSQRT2, createTyped, createWeakMixingAngle, createAbs, createAcos, createAcot, createAcsc, createAddScalar, createArg, createAsech, createAsinh, createAtan, createAtanh, createBigint, createBitNot, createBoolean, createClone, createCombinations, createComplex, createConj, createCos, createCot, createCsc, createCube, createEqualScalar, createErf, createExp, createExpm1, createFilter, createFlatten, createForEach, createFormat, createGetMatrixDataType, createHex, createIm, createIsInteger, createIsNegative, createIsPositive, createIsZero, createLOG2E, createLgamma, createLog10, createLog2, createMap, createMultiplyScalar, createNot, createNumber, createOct, createPickRandom, createPrint, createRandom, createRe, createSec, createSign, createSin, createSparseMatrixClass, createSplitUnit, createSquare, createString, createSubtractScalar, createTan, createTypeOf, createAcosh, createAcsch, createAsec, createBignumber, createCombinationsWithRep, createCosh, createCsch, createIsNaN, createIsPrime, createMapSlices, createMatrix, createMatrixFromFunction, createOnes, createRandomInt, createReshape, createSech, createSinh, createSparse, createSqrt, createSqueeze, createTanh, createTranspose, createXgcd, createZeros, createAcoth, createAsin, createBin, createConcat, createCoth, createCtranspose, createDiag, createDotMultiply, createEqual, createFraction, createIdentity, createIsNumeric, createKron, createLargerEq, createLeftShift, createMode, createNthRoot, createNumeric, createProd, createResize, createRightArithShift, createRound, createSize, createSmaller, createTo, createUnaryMinus, createUnequal, createXor, createAdd, createAtan2, createBitAnd, createBitOr, createBitXor, createCbrt, createCompare, createCompareText, createCount, createDeepEqual, createDivideScalar, createDotDivide, createEqualText, createFloor, createGcd, createHasNumericValue, createHypot, createImmutableDenseMatrixClass, createIndexClass, createLarger, createLog, createLsolve, createMatrixFromColumns, createMax, createMin, createMod, createNthRoots, createOr, createPartitionSelect, createQr, createRightLogShift, createSmallerEq, createSubset, createSubtract, createTrace, createUsolve, createCatalan, createCompareNatural, createComposition, createDiff, createDistance, createDot, createFibonacciHeapClass, createIndex, createInvmod, createLcm, createLog1p, createLsolveAll, createMatrixFromRows, createMultiply, createRange, createRow, createSetCartesian, createSetDistinct, createSetIsSubset, createSetPowerset, createSlu, createSort, createUnaryPlus, createUsolveAll, createZpk2tf, createAnd, createCeil, createColumn, createCross, createDet, createFix, createInv, createPinv, createPow, createSetDifference, createSetMultiplicity, createSetSymDifference, createSpaClass, createSqrtm, createSum, createUnitClass, createVacuumImpedance, createWienDisplacement, createAtomicMass, createBohrMagneton, createBoltzmann, createConductanceQuantum, createCoulomb, createCreateUnit, createDeuteronMass, createDotPow, createElectricConstant, createElementaryCharge, createExpm, createFaraday, createFft, createGamma, createGravitationConstant, createHartreeEnergy, createIfft, createInverseConductanceQuantum, createKlitzing, createLoschmidt, createMagneticConstant, createMolarMass, createMolarPlanckConstant, createNeutronMass, createNuclearMagneton, createPlanckCharge, createPlanckLength, createPlanckTemperature, createProtonMass, createQuantumOfCirculation, createReducedPlanckConstant, createRydberg, createSecondRadiation, createSetSize, createSpeedOfLight, createStefanBoltzmann, createThomsonCrossSection, createAvogadro, createBohrRadius, createCoulombConstant, createDivide, createElectronMass, createFactorial, createFirstRadiation, createGravity, createIntersect, createLup, createMagneticFluxQuantum, createMolarMassC12, createMultinomial, createPermutations, createPlanckMass, createPolynomialRoot, createSetIntersect, createSolveODE, createStirlingS2, createUnitFunction, createBellNumbers, createCumSum, createEigs, createFermiCoupling, createGasConstant, createKldivergence, createLusolve, createMean, createMolarVolume, createPlanckConstant, createQuantileSeq, createSetUnion, createVariance, createClassicalElectronRadius, createMedian, createCorr, createFreqz, createMad, createStd, createZeta, createNorm, createRotationMatrix, createPlanckTime, createSchur, createRotate, createSylvester, createLyap } from '../factoriesAny.js';
+createSackurTetrode, createTau, createTrue, createVersion, createDenseMatrixClass, createEfimovFactor, createLN2, createPi, createReplacer, createSQRT2, createTyped, createWeakMixingAngle, createAbs, createAcos, createAcot, createAcsc, createAddScalar, createArg, createAsech, createAsinh, createAtan, createAtanh, createBigint, createBitNot, createBoolean, createClone, createCombinations, createComplex, createConj, createCos, createCot, createCsc, createCube, createEqualScalar, createErf, createExp, createExpm1, createFilter, createFlatten, createForEach, createFormat, createGetMatrixDataType, createHex, createIm, createIsInteger, createIsNegative, createIsPositive, createIsZero, createLOG2E, createLgamma, createLog10, createLog2, createMap, createMultiplyScalar, createNot, createNumber, createOct, createPickRandom, createPrint, createRandom, createRe, createSec, createSign, createSin, createSparseMatrixClass, createSplitUnit, createSquare, createString, createSubtractScalar, createTan, createToBest, createTypeOf, createAcosh, createAcsch, createAsec, createBignumber, createCombinationsWithRep, createCosh, createCsch, createIsNaN, createIsPrime, createMapSlices, createMatrix, createMatrixFromFunction, createOnes, createRandomInt, createReshape, createSech, createSinh, createSparse, createSqrt, createSqueeze, createTanh, createTranspose, createXgcd, createZeros, createAcoth, createAsin, createBin, createConcat, createCoth, createCtranspose, createDiag, createDotMultiply, createEqual, createFraction, createIdentity, createIsNumeric, createKron, createLargerEq, createLeftShift, createMode, createNthRoot, createNumeric, createProd, createResize, createRightArithShift, createRound, createSize, createSmaller, createTo, createUnaryMinus, createUnequal, createXor, createAdd, createAtan2, createBitAnd, createBitOr, createBitXor, createCbrt, createCompare, createCompareText, createCount, createDeepEqual, createDivideScalar, createDotDivide, createEqualText, createFloor, createGcd, createHasNumericValue, createHypot, createImmutableDenseMatrixClass, createIndexClass, createLarger, createLog, createLsolve, createMatrixFromColumns, createMax, createMin, createMod, createNthRoots, createOr, createPartitionSelect, createQr, createRightLogShift, createSmallerEq, createSubset, createSubtract, createTrace, createUsolve, createCatalan, createCompareNatural, createComposition, createDiff, createDistance, createDot, createFibonacciHeapClass, createIndex, createInvmod, createLcm, createLog1p, createLsolveAll, createMatrixFromRows, createMultiply, createRange, createRow, createSetCartesian, createSetDistinct, createSetIsSubset, createSetPowerset, createSlu, createSort, createUnaryPlus, createUsolveAll, createZpk2tf, createAnd, createCeil, createColumn, createCross, createDet, createFix, createInv, createPinv, createPow, createSetDifference, createSetMultiplicity, createSetSymDifference, createSpaClass, createSqrtm, createSum, createUnitClass, createVacuumImpedance, createWienDisplacement, createAtomicMass, createBohrMagneton, createBoltzmann, createConductanceQuantum, createCoulomb, createCreateUnit, createDeuteronMass, createDotPow, createElectricConstant, createElementaryCharge, createExpm, createFaraday, createFft, createGamma, createGravitationConstant, createHartreeEnergy, createIfft, createInverseConductanceQuantum, createKlitzing, createLoschmidt, createMagneticConstant, createMolarMass, createMolarPlanckConstant, createNeutronMass, createNuclearMagneton, createPlanckCharge, createPlanckLength, createPlanckTemperature, createProtonMass, createQuantumOfCirculation, createReducedPlanckConstant, createRydberg, createSecondRadiation, createSetSize, createSpeedOfLight, createStefanBoltzmann, createThomsonCrossSection, createAvogadro, createBohrRadius, createCoulombConstant, createDivide, createElectronMass, createFactorial, createFirstRadiation, createGravity, createIntersect, createLup, createMagneticFluxQuantum, createMolarMassC12, createMultinomial, createPermutations, createPlanckMass, createPolynomialRoot, createSetIntersect, createSolveODE, createStirlingS2, createUnitFunction, createBellNumbers, createCumSum, createEigs, createFermiCoupling, createGasConstant, createKldivergence, createLusolve, createMean, createMolarVolume, createPlanckConstant, createQuantileSeq, createSetUnion, createVariance, createClassicalElectronRadius, createMedian, createCorr, createFreqz, createMad, createStd, createZeta, createNorm, createRotationMatrix, createPlanckTime, createSchur, createRotate, createSylvester, createLyap } from '../factoriesAny.js';
 export var BigNumber = /* #__PURE__ */createBigNumberClass({
   config
 });
@@ -300,6 +300,9 @@ export var subtractScalar = /* #__PURE__ */createSubtractScalar({
 export var tan = /* #__PURE__ */createTan({
   typed
 });
+export var toBest = /* #__PURE__ */createToBest({
+  typed
+});
 export var typeOf = /* #__PURE__ */createTypeOf({
   typed
 });
@@ -1177,7 +1180,8 @@ export var Unit = /* #__PURE__ */createUnitClass({
   number,
   pow,
   round,
-  subtractScalar
+  subtractScalar,
+  toBest
 });
 export var vacuumImpedance = /* #__PURE__ */createVacuumImpedance({
   BigNumber,

package/lib/esm/expression/Parser.js

@@ -1,4 +1,5 @@
 import { factory } from '../utils/factory.js';
+import { isFunction } from '../utils/is.js';
 import { createEmptyMap, toObject } from '../utils/map.js';
 var name = 'Parser';
 var dependencies = ['evaluate', 'parse'];
@@ -154,7 +155,40 @@ export var createParserClass = /* #__PURE__ */factory(name, dependencies, _ref =
   Parser.prototype.clear = function () {
     this.scope.clear();
   };
+  Parser.prototype.toJSON = function () {
+    var json = {
+      mathjs: 'Parser',
+      variables: {},
+      functions: {}
+    };
+    for (var [_name2, value] of this.scope) {
+      if (isFunction(value)) {
+        if (!isExpressionFunction(value)) {
+          throw new Error("Cannot serialize external function ".concat(_name2));
+        }
+        json.functions[_name2] = "".concat(value.syntax, " = ").concat(value.expr);
+      } else {
+        json.variables[_name2] = value;
+      }
+    }
+    return json;
+  };
+  Parser.fromJSON = function (json) {
+    var parser = new Parser();
+    Object.entries(json.variables).forEach(_ref2 => {
+      var [name, value] = _ref2;
+      return parser.set(name, value);
+    });
+    Object.entries(json.functions).forEach(_ref3 => {
+      var [_name, fn] = _ref3;
+      return parser.evaluate(fn);
+    });
+    return parser;
+  };
   return Parser;
 }, {
   isClass: true
-});
+});
+function isExpressionFunction(value) {
+  return typeof value === 'function' && typeof value.syntax === 'string' && typeof value.expr === 'string';
+}

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

@@ -229,6 +229,7 @@ import { sinhDocs } from './function/trigonometry/sinh.js';
 import { tanDocs } from './function/trigonometry/tan.js';
 import { tanhDocs } from './function/trigonometry/tanh.js';
 import { toDocs } from './function/units/to.js';
+import { toBestDocs } from './function/units/toBest.js';
 import { binDocs } from './function/utils/bin.js';
 import { cloneDocs } from './function/utils/clone.js';
 import { formatDocs } from './function/utils/format.js';
@@ -712,6 +713,7 @@ export var embeddedDocs = {
   tanh: tanhDocs,
   // functions - units
   to: toDocs,
+  toBest: toBestDocs,
   // functions - utils
   clone: cloneDocs,
   format: formatDocs,

package/lib/esm/expression/embeddedDocs/function/units/toBest.js

@@ -0,0 +1,8 @@
+export var toBestDocs = {
+  name: 'toBest',
+  category: 'Units',
+  syntax: ['toBest(x)', 'toBest(x, unitList)', 'toBest(x, unitList, options)'],
+  description: 'Converts to the most appropriate display unit.',
+  examples: ['toBest(unit(5000, "m"))', 'toBest(unit(3500000, "W"))', 'toBest(unit(0.000000123, "A"))', 'toBest(unit(10, "m"), "cm")', 'toBest(unit(10, "m"), "mm,km", {offset: 1.5})'],
+  seealso: []
+};

package/lib/esm/expression/node/FunctionAssignmentNode.js

@@ -98,7 +98,8 @@ export var createFunctionAssignmentNode = /* #__PURE__ */factory(name, dependenc
       });
 
       // compile the function expression with the child args
-      var evalExpr = this.expr._compile(math, childArgNames);
+      var expr = this.expr;
+      var evalExpr = expr._compile(math, childArgNames);
       var name = this.name;
       var params = this.params;
       var signature = join(this.types, ',');
@@ -114,6 +115,7 @@ export var createFunctionAssignmentNode = /* #__PURE__ */factory(name, dependenc
         };
         var fn = typed(name, signatures);
         fn.syntax = syntax;
+        fn.expr = expr.toString();
         scope.set(name, fn);
         return fn;
       };

package/lib/esm/expression/parse.js

@@ -47,7 +47,7 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
    *     node1.compile().evaluate() // 5
    *
    *     let scope = {a:3, b:4}
-   *     const node2 = math.parse('a * b') // 12
+   *     const node2 = math.parse('a * b')
    *     node2.evaluate(scope) // 12
    *     const code2 = node2.compile()
    *     code2.evaluate(scope) // 12

package/lib/esm/factoriesAny.js

@@ -107,6 +107,7 @@ export { createOct } from './function/string/oct.js';
 export { createHex } from './function/string/hex.js';
 export { createPrint } from './function/string/print.js';
 export { createTo } from './function/unit/to.js';
+export { createToBest } from './function/unit/toBest.js';
 export { createIsPrime } from './function/utils/isPrime.js';
 export { createNumeric } from './function/utils/numeric.js';
 export { createDivideScalar } from './function/arithmetic/divideScalar.js';

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

@@ -52,7 +52,7 @@ export var createSign = /* #__PURE__ */factory(name, dependencies, _ref => {
       return x > 0n ? 1n : x < 0n ? -1n : 0n;
     },
     Fraction: function Fraction(x) {
-      return new _Fraction(x.s);
+      return x.n === 0n ? new _Fraction(0) : new _Fraction(x.s);
     },
     // deep map collection, skip zeros since sign(0) = 0
     'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self, true)),

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

@@ -16,7 +16,7 @@ export var createRange = /* #__PURE__ */factory(name, dependencies, _ref => {
     isPositive
   } = _ref;
   /**
-   * Create an array from a range.
+   * Create a matrix or array containing a range of values.
    * By default, the range end is excluded. This can be customized by providing
    * an extra parameter `includeEnd`.
    *
@@ -44,10 +44,12 @@ export var createRange = /* #__PURE__ */factory(name, dependencies, _ref => {
    * - `includeEnd: boolean`
    *   Option to specify whether to include the end or not. False by default.
    *
-   * Note that the return type of the range is taken from the type of
-   * the start/end. If only one these is a built-in `number` type, it will
-   * be promoted to the type of the other endpoint. However, in the case of
-   * Unit values, both endpoints must have compatible units, and the return
+   * The function returns a `DenseMatrix` when the library is configured with
+   * `config = { matrix: 'Matrix' }, and returns an Array otherwise.
+   * Note that the type of the returned values is taken from the type of the
+   * provided start/end value. If only one of these is a built-in `number` type,
+   * it will be promoted to the type of the other endpoint. However, in the case
+   * of Unit values, both endpoints must have compatible units, and the return
    * value will have compatible units as well.
    *
    * Examples:

package/lib/esm/function/unit/toBest.js

@@ -0,0 +1,47 @@
+import { factory } from '../../utils/factory.js';
+var name = 'toBest';
+var dependencies = ['typed'];
+export var createToBest = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed
+  } = _ref;
+  /**
+   * Converts a unit to the most appropriate display unit.
+   * When no preferred units are provided, the function automatically find the best prefix.
+   * When preferred units are provided, it converts to
+   * the unit that gives a value closest to 1.
+   *
+   * Syntax:
+   *
+   *    math.toBest(unit)
+   *    math.toBest(unit, unitList)
+   *    math.toBest(unit, unitList, options)
+   *
+   * Where:
+   * - `unitList` is an optional array of preferred target units as string or Unit.
+   * - `options` is an optional object with options, formed as follows:
+   * - `offset`: number | BigNumber
+   *
+   * Examples:
+   *
+   *   math.unit(0.05, 'm').toBest(['cm', 'mm'])                 // returns Unit 5 cm
+   *   math.unit(2 / 3, 'cm').toBest()                           // returns Unit 0.6666666666666666 cm
+   *   math.unit(10, 'm').toBest(['mm', 'km'], { offset: 1.5 })  // returns Unit 10000 mm
+   *
+   * See also:
+   *
+   *    unit, to, format
+   *
+   * @param {Unit} x                          The unit to be converted
+   * @param {Array<string>} [unitList=[]]     Optional array of preferred target units
+   * @param {Object} [options]                Optional options object
+   * @return {Unit}                           Value converted to the best matching unit
+   */
+  return typed(name, {
+    Unit: x => x.toBest(),
+    'Unit, string': (x, unitList) => x.toBest(unitList.split(',')),
+    'Unit, string, Object': (x, unitList, options) => x.toBest(unitList.split(','), options),
+    'Unit, Array': (x, unitList) => x.toBest(unitList),
+    'Unit, Array, Object': (x, unitList, options) => x.toBest(unitList, options)
+  });
+});

package/lib/esm/type/matrix/DenseMatrix.js

@@ -672,24 +672,28 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
       }
       return;
     }
-    var index = [];
-    var _recurse = function* recurse(value, depth) {
-      if (depth < maxDepth) {
-        for (var _i9 = 0; _i9 < value.length; _i9++) {
-          index[depth] = _i9;
-          yield* _recurse(value[_i9], depth + 1);
-        }
-      } else {
-        for (var _i0 = 0; _i0 < value.length; _i0++) {
-          index[depth] = _i0;
-          yield {
-            value: value[_i0],
-            index: index.slice()
-          };
-        }
+
+    // Multi-dimensional matrix: iterate over all elements
+    var index = Array(maxDepth + 1).fill(0);
+    var totalElements = this._size.reduce((a, b) => a * b, 1);
+    for (var count = 0; count < totalElements; count++) {
+      // Traverse to the current element using indices
+      var current = this._data;
+      for (var d = 0; d < maxDepth; d++) {
+        current = current[index[d]];
       }
-    };
-    yield* _recurse(this._data, 0);
+      yield {
+        value: current[index[maxDepth]],
+        index: index.slice()
+      };
+
+      // Increment indices for next element
+      for (var _d = maxDepth; _d >= 0; _d--) {
+        index[_d]++;
+        if (index[_d] < this._size[_d]) break;
+        index[_d] = 0;
+      }
+    }
   };
 
   /**

package/lib/esm/type/string.js

@@ -17,13 +17,13 @@ export var createString = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    * Examples:
    *
-   *    math.string(4.2)               // returns string '4.2'
-   *    math.string(math.complex(3, 2) // returns string '3 + 2i'
+   *    math.string(4.2)                // returns string '4.2'
+   *    math.string(math.complex(3, 2)) // returns string '3 + 2i'
    *
    *    const u = math.unit(5, 'km')
-   *    math.string(u.to('m'))         // returns string '5000 m'
+   *    math.string(u.to('m'))          // returns string '5000 m'
    *
-   *    math.string([true, false])     // returns ['true', 'false']
+   *    math.string([true, false])      // returns ['true', 'false']
    *
    * See also:
    *

package/lib/esm/type/unit/Unit.js

@@ -9,7 +9,7 @@ import { endsWith } from '../../utils/string.js';
 import { clone, hasOwnProperty } from '../../utils/object.js';
 import { createBigNumberPi as createPi } from '../../utils/bignumber/constants.js';
 var name = 'Unit';
-var dependencies = ['?on', 'config', 'addScalar', 'subtractScalar', 'multiplyScalar', 'divideScalar', 'pow', 'abs', 'fix', 'round', 'equal', 'isNumeric', 'format', 'number', 'Complex', 'BigNumber', 'Fraction'];
+var dependencies = ['?on', 'config', 'addScalar', 'subtractScalar', 'multiplyScalar', 'divideScalar', 'pow', 'abs', 'fix', 'round', 'equal', 'isNumeric', 'format', 'toBest', 'number', 'Complex', 'BigNumber', 'Fraction'];
 export var createUnitClass = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     on,
@@ -25,6 +25,7 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, _ref =>
     equal,
     isNumeric,
     format,
+    toBest,
     number: _number,
     Complex,
     BigNumber: _BigNumber,
@@ -1041,6 +1042,54 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, _ref =>
     return str;
   };
 
+  /**
+   * Get a unit, with optional formatting options.
+   * @memberof Unit
+   * @param {string[] | Unit[]} [units]  Array of units strings or valueLess Unit objects in wich choose the best one
+   * @param {Object} [options]  Options for parsing the unit. See parseUnit for details.
+   *
+   * @return {Unit} Returns a new Unit with the given value and unit.
+   */
+  Unit.prototype.toBest = function () {
+    var unitList = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    if (unitList && !Array.isArray(unitList)) {
+      throw new Error('Invalid unit type. Expected string or Unit.');
+    }
+    var startPrefixes = this.units[0].unit.prefixes;
+    if (unitList && unitList.length > 0) {
+      var unitObjects = unitList.map(u => {
+        var unit = null;
+        if (typeof u === 'string') {
+          unit = Unit.parse(u);
+          if (!unit) {
+            throw new Error('Invalid unit type. Expected compatible string or Unit.');
+          }
+        } else if (!isUnit(u)) {
+          throw new Error('Invalid unit type. Expected compatible string or Unit.');
+        }
+        if (unit === null) {
+          unit = u.clone();
+        }
+        try {
+          this.to(unit.formatUnits());
+          return unit;
+        } catch (e) {
+          throw new Error('Invalid unit type. Expected compatible string or Unit.');
+        }
+      });
+      var prefixes = unitObjects.map(el => el.units[0].prefix);
+      this.units[0].unit.prefixes = prefixes.reduce((acc, prefix) => {
+        acc[prefix.name] = prefix;
+        return acc;
+      }, {});
+      this.units[0].prefix = prefixes[0];
+    }
+    var result = formatBest(this, options).simp;
+    this.units[0].unit.prefixes = startPrefixes;
+    result.fixPrefix = true;
+    return result;
+  };
   /**
    * Get a string representation of the Unit, with optional formatting options.
    * @memberof Unit
@@ -1051,11 +1100,54 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, _ref =>
    * @return {string}
    */
   Unit.prototype.format = function (options) {
+    var {
+      simp,
+      valueStr,
+      unitStr
+    } = formatBest(this, options);
+    var str = valueStr;
+    if (simp.value && isComplex(simp.value)) {
+      str = '(' + str + ')'; // Surround complex values with ( ) to enable better parsing
+    }
+    if (unitStr.length > 0 && str.length > 0) {
+      str += ' ';
+    }
+    str += unitStr;
+    return str;
+  };
+
+  /**
+  * Helper function to normalize a unit for conversion and formatting
+  * @param {Unit} unit The unit to be normalized
+  * @return {Object} Object with normalized unit and value
+  * @private
+  */
+  function formatBest(unit) {
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     // Simplfy the unit list, unless it is valueless or was created directly in the
     // constructor or as the result of to or toSI
-    var simp = this.skipAutomaticSimplification || this.value === null ? this.clone() : this.simplify();
+    var simp = unit.skipAutomaticSimplification || unit.value === null ? unit.clone() : unit.simplify();
 
     // Apply some custom logic for handling VA and VAR. The goal is to express the value of the unit as a real value, if possible. Otherwise, use a real-valued unit instead of a complex-valued one.
+    handleVAandVARUnits(simp);
+    // Now apply the best prefix
+    // Units must have only one unit and not have the fixPrefix flag set
+    applyBestPrefixIfNeeded(simp, options.offset);
+    var value = simp._denormalize(simp.value);
+    var valueStr = simp.value !== null ? format(value, options || {}) : '';
+    var unitStr = simp.formatUnits();
+    return {
+      simp,
+      valueStr,
+      unitStr
+    };
+  }
+
+  /**
+   * Helper to handle VA and VAR units
+   * @param {Unit} simp The unit to be normalized
+   */
+  function handleVAandVARUnits(simp) {
     var isImaginary = false;
     if (typeof simp.value !== 'undefined' && simp.value !== null && isComplex(simp.value)) {
       // TODO: Make this better, for example, use relative magnitude of re and im rather than absolute
@@ -1072,37 +1164,32 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, _ref =>
         }
       }
     }
+  }
 
-    // Now apply the best prefix
-    // Units must have only one unit and not have the fixPrefix flag set
+  /**
+   * Helper to apply the best prefix if needed
+   * @param {Unit} simp The unit to be normalized
+   */
+  function applyBestPrefixIfNeeded(simp, offset) {
     if (simp.units.length === 1 && !simp.fixPrefix) {
       // Units must have integer powers, otherwise the prefix will change the
       // outputted value by not-an-integer-power-of-ten
       if (Math.abs(simp.units[0].power - Math.round(simp.units[0].power)) < 1e-14) {
         // Apply the best prefix
-        simp.units[0].prefix = simp._bestPrefix();
+        simp.units[0].prefix = simp._bestPrefix(offset);
       }
     }
-    var value = simp._denormalize(simp.value);
-    var str = simp.value !== null ? format(value, options || {}) : '';
-    var unitStr = simp.formatUnits();
-    if (simp.value && isComplex(simp.value)) {
-      str = '(' + str + ')'; // Surround complex values with ( ) to enable better parsing
-    }
-    if (unitStr.length > 0 && str.length > 0) {
-      str += ' ';
-    }
-    str += unitStr;
-    return str;
-  };
+  }
 
   /**
    * Calculate the best prefix using current value.
    * @memberof Unit
    * @returns {Object} prefix
+   * @param {number} [offset]  Optional offset for the best prefix calculation (default 1.2)
    * @private
    */
   Unit.prototype._bestPrefix = function () {
+    var offset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1.2;
     if (this.units.length !== 1) {
       throw new Error('Can only compute the best prefix for single units with integer powers, like kg, s^2, N^-1, and so forth!');
     }
@@ -1125,7 +1212,7 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, _ref =>
       return bestPrefix;
     }
     var power = this.units[0].power;
-    var bestDiff = Math.log(absValue / Math.pow(bestPrefix.value * absUnitValue, power)) / Math.LN10 - 1.2;
+    var bestDiff = Math.log(absValue / Math.pow(bestPrefix.value * absUnitValue, power)) / Math.LN10 - offset;
     if (bestDiff > -2.200001 && bestDiff < 1.800001) return bestPrefix; // Allow the original prefix
     bestDiff = Math.abs(bestDiff);
     var prefixes = this.units[0].unit.prefixes;
@@ -1133,7 +1220,7 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, _ref =>
       if (hasOwnProperty(prefixes, p)) {
         var prefix = prefixes[p];
         if (prefix.scientific) {
-          var diff = Math.abs(Math.log(absValue / Math.pow(prefix.value * absUnitValue, power)) / Math.LN10 - 1.2);
+          var diff = Math.abs(Math.log(absValue / Math.pow(prefix.value * absUnitValue, power)) / Math.LN10 - offset);
           if (diff < bestDiff || diff === bestDiff && prefix.name.length < bestPrefix.name.length) {
             // choose the prefix with the smallest diff, or if equal, choose the one
             // with the shortest name (can happen with SHORTLONG for example)

package/lib/esm/version.js

@@ -1,3 +1,3 @@
-export var version = '14.5.3';
+export var version = '14.7.0';
 // Note: This file is automatically generated when building math.js.
 // Changes made in this file will be overwritten.