Consistency and typing problems in isNumeric and hasNumericValue

[gwhitney]

Describe the bug

• Complex numbers are surely numbers, just from a different system. Yet isNumeric and hasNumericValue return false on them. This directly contradicts (for example) the TypeScript type definition MathNumericType = number | BigNumber | Fraction | Complex
• isNumeric and hasNumericValue fail on e.g. {a: 1, b: 2}. Surely they should not fail on any inputs. In this particular case, I think the desired return value is 'false'. One could make an argument for {a: true, b: true} by analogy with how Arrays are handled, but I don't think any mathjs functions distribute over object structure in this way.
• Whether booleans are isNumeric is very debatable. And the fact it currently returns true contradicts the TypeScript MathNumericType definition, in the opposite direction from Complex. Certainly a boolean hasNumericValue in exactly the same way as a string does, in that they automatically convert to 0 and 1 in any numeric context. But the fact that true * false is 0 rather than false, the same way that "1" * "0" is just 0 not "0" suggests that booleans are not themselves numeric. I would strongly suggest leaving hasNumericValue true for booleans, and either:
  • making isNumeric false for booleans, or
  • making * non-short-circuiting and, and + non-short-circuiting or. Then the booleans are exactly a copy of the field of two elements -- definitely numeric. And in this case, add boolean to TypeScript MathNumericType, which should align with isNumeric.
• Typescript typing of isNumeric is currently: isNumeric(x: any): x is number | BigNumber | Fraction | boolean. This is wrong in three ways:
  • isNumeric only accepts (currently a subset of) MathTypes, not truly any value. It could be extended to return false on anything else, in which case the input type is correct (but should be changed to x: unknown to comport with current usage and eliminate the disabling of the any rule); or the typing could be changed to reflect the types it actually takes.
  • isNumeric is not (at least not currently) a type guard. It does not even always return a boolean value (e.g. on arrays).
  • Even when isNumeric returns a truthy value, its argument is not necessarily one of the listed types. It could be a bigint, or an Array or a Matrix.
• Typescript typing of hasNumericValue should be similar to that for isNumeric and hence might need to be updated when the typing of isNumeric is fixed in some way or another.
• Since isNumeric returning a truthy value does not guarantee that its argument is a scalar, mathjs should have an isScalar function that does serve as a type guard. Otherwise, it is difficult to use the result of math.evaluate() in some mathjs functions in typescript.

To Reproduce

math.isNumeric(Complex(1,2)) // returns false, expect true

math.isNumeric(false) // returns true, dubious

math.isNumeric({a: 1, b:2}) // throws TypeError, expect successful return of false

if (math.isNumeric(A)) return A[0] // could be perfectly OK code, but TypeScript reports: error TS7053: 
// Element implicitly has an 'any' type because expression of type '0' can't be used to
// index type 'number | BigNumber | Fraction'.

if (math.isNumeric(n)) x = math.cube(n) // No TypeScript error, but is not actually OK; can
// throw a TypeError at runtime if n happens to be [3, 4, 5], say.

return math.isNumeric([3,4,5])[0] // Is perfectly OK, but TypeScript reports: error TS7053 for type Boolean.