fix: use utility isNaN for consistent max and min results

src/expression/transform/max.transform.js

@@ -4,10 +4,10 @@ import { createMax } from '../../function/statistics/max.js'
 import { lastDimToZeroBase } from './utils/lastDimToZeroBase.js'
 
 const name = 'max'
-const dependencies = ['typed', 'config', 'numeric', 'larger']
+const dependencies = ['typed', 'config', 'numeric', 'larger', 'isNaN']
 
-export const createMaxTransform = /* #__PURE__ */ factory(name, dependencies, ({ typed, config, numeric, larger }) => {
-  const max = createMax({ typed, config, numeric, larger })
+export const createMaxTransform = /* #__PURE__ */ factory(name, dependencies, ({ typed, config, numeric, larger, isNaN }) => {
+  const max = createMax({ typed, config, numeric, larger, isNaN })
 
   /**
    * Attach a transform function to math.max

src/expression/transform/min.transform.js

@@ -4,10 +4,10 @@ import { createMin } from '../../function/statistics/min.js'
 import { lastDimToZeroBase } from './utils/lastDimToZeroBase.js'
 
 const name = 'min'
-const dependencies = ['typed', 'config', 'numeric', 'smaller']
+const dependencies = ['typed', 'config', 'numeric', 'smaller', 'isNaN']
 
-export const createMinTransform = /* #__PURE__ */ factory(name, dependencies, ({ typed, config, numeric, smaller }) => {
-  const min = createMin({ typed, config, numeric, smaller })
+export const createMinTransform = /* #__PURE__ */ factory(name, dependencies, ({ typed, config, numeric, smaller, isNaN }) => {
+  const min = createMin({ typed, config, numeric, smaller, isNaN })
 
   /**
    * Attach a transform function to math.min

src/function/statistics/max.js

@@ -4,9 +4,9 @@ import { safeNumberType } from '../../utils/number.js'
 import { improveErrorMessage } from './utils/improveErrorMessage.js'
 
 const name = 'max'
-const dependencies = ['typed', 'config', 'numeric', 'larger']
+const dependencies = ['typed', 'config', 'numeric', 'larger', 'isNaN']
 
-export const createMax = /* #__PURE__ */ factory(name, dependencies, ({ typed, config, numeric, larger }) => {
+export const createMax = /* #__PURE__ */ factory(name, dependencies, ({ typed, config, numeric, larger, isNaN }) => {
   /**
    * Compute the maximum value of a matrix or a  list with values.
    * In case of a multidimensional array, the maximum of the flattened array
@@ -83,8 +83,8 @@ export const createMax = /* #__PURE__ */ factory(name, dependencies, ({ typed, c
 
     deepForEach(array, function (value) {
       try {
-        if (typeof value === 'number' && isNaN(value)) {
-          res = NaN
+        if (isNaN(value)) {
+          res = value
         } else if (res === undefined || larger(value, res)) {
           res = value
         }

src/function/statistics/min.js

@@ -4,9 +4,9 @@ import { safeNumberType } from '../../utils/number.js'
 import { improveErrorMessage } from './utils/improveErrorMessage.js'
 
 const name = 'min'
-const dependencies = ['typed', 'config', 'numeric', 'smaller']
+const dependencies = ['typed', 'config', 'numeric', 'smaller', 'isNaN']
 
-export const createMin = /* #__PURE__ */ factory(name, dependencies, ({ typed, config, numeric, smaller }) => {
+export const createMin = /* #__PURE__ */ factory(name, dependencies, ({ typed, config, numeric, smaller, isNaN }) => {
   /**
    * Compute the minimum value of a matrix or a  list of values.
    * In case of a multidimensional array, the minimum of the flattened array
@@ -83,8 +83,8 @@ export const createMin = /* #__PURE__ */ factory(name, dependencies, ({ typed, c
 
     deepForEach(array, function (value) {
       try {
-        if (typeof value === 'number' && isNaN(value)) {
-          min = NaN
+        if (isNaN(value)) {
+          min = value
         } else if (min === undefined || smaller(value, min)) {
           min = value
         }

test/unit-tests/function/statistics/max.test.js

@@ -5,6 +5,7 @@ const Complex = math.Complex
 const DenseMatrix = math.DenseMatrix
 const fraction = math.fraction
 const max = math.max
+const unit = math.unit
 
 describe('max', function () {
   it('should return the max of numbers', function () {
@@ -89,6 +90,10 @@ describe('max', function () {
     assert(isNaN(max([1, 3, NaN])))
     assert(isNaN(max([NaN, NaN, NaN])))
     assert(isNaN(max(NaN, NaN)))
+    assert(isNaN(max(BigNumber(NaN), BigNumber(123))))
+    assert(isNaN((max(BigNumber(123), BigNumber(NaN), NaN))))
+    assert(isNaN(max(unit(NaN, 's'), unit(123, 's')).value))
+    assert(isNaN(max(unit(123, 's'), unit(NaN, 's')).value))
   })
 
   it('should return the largest of mixed types', function () {
@@ -124,8 +129,8 @@ describe('max', function () {
     assert.throws(function () { max([[2, new Date(), 4]]) }, /TypeError: Cannot calculate max, unexpected type of argument/)
     assert.throws(function () { max([2, null, 4]) }, /TypeError: Cannot calculate max, unexpected type of argument/)
     assert.throws(function () { max([[2, 5], [4, null], [1, 7]], 0) }, /TypeError: Cannot calculate max, unexpected type of argument/)
-    assert.throws(function () { max('a', 'b') }, /Error: Cannot convert "b" to a number/)
-    assert.throws(function () { max('a') }, /SyntaxError: String "a" is not a valid number/)
+    assert.throws(function () { max('a', 'b') }, /Error: Cannot convert "a" to a number/)
+    assert.throws(function () { max('a') }, /Error: Cannot convert "a" to a number/)
   })
 
   it('should return undefined if called with an empty array', function () {

test/unit-tests/function/statistics/min.test.js

@@ -5,6 +5,7 @@ const Complex = math.Complex
 const DenseMatrix = math.DenseMatrix
 const fraction = math.fraction
 const min = math.min
+const unit = math.unit
 
 describe('min', function () {
   it('should return the min between several numbers', function () {
@@ -98,6 +99,10 @@ describe('min', function () {
     assert(isNaN(min([1, 3, NaN])))
     assert(isNaN(min([NaN, NaN, NaN])))
     assert(isNaN(min(NaN, NaN, NaN)))
+    assert(isNaN(min(BigNumber(NaN), BigNumber(123))))
+    assert(isNaN((min(BigNumber(123), BigNumber(NaN), NaN))))
+    assert(isNaN(min(unit(NaN, 's'), unit(123, 's')).value))
+    assert(isNaN(min(unit(123, 's'), unit(NaN, 's')).value))
   })
 
   it('should return the smallest of mixed types', function () {
@@ -137,8 +142,8 @@ describe('min', function () {
     assert.throws(function () { min([[2, new Date(), 4]]) }, /TypeError: Cannot calculate min, unexpected type of argument/)
     assert.throws(function () { min([2, null, 4]) }, /TypeError: Cannot calculate min, unexpected type of argument/)
     assert.throws(function () { min([[2, 5], [4, null], [1, 7]], 0) }, /TypeError: Cannot calculate min, unexpected type of argument/)
-    assert.throws(function () { min('a', 'b') }, /Error: Cannot convert "b" to a number/)
-    assert.throws(function () { min('a') }, /SyntaxError: String "a" is not a valid number/)
+    assert.throws(function () { min('a', 'b') }, /Error: Cannot convert "a" to a number/)
+    assert.throws(function () { min('a') }, /Error: Cannot convert "a" to a number/)
   })
 
   it('should LaTeX min', function () {