V11 with typed-function@3 (#2560)

* refactor: Remove the automatic conversion from number to string. (#2482)

This is a breaking change. However, nothing in the unit tests or examples
  actually depended on such a conversion, and it's difficult to construct
  situations in which it's necessary. The best such example is e.g.
  `count(57)` which formerly gave the number of digits in its numeric
  argument. Of course, after this commit, that behavior can still be
  obtained by the just slightly longer expression `count(string(57))`

  The change is proposed in preparation for an addition of new facilities/
  handlers to allow symbolic computation in a couple of different ways
  (see #2475 and #2470).

* feat(simplifyCore): convert equivalent function calls into operators (#2466)

* feat(simplifyCore): convert equivalent function calls into operators

  Resolves #2415.

* docs: Every operator has a function form

  Also documents the new behavior of simplifyCore to convert function calls
  into any equivalent operator form they may have. Also fixes the syntax
  errors so that simplifyCore will successfully doctest.

* docs: Fix table syntax for operator->function correspondence

* fix(parse): Implement amended "Rule 2"

  As per the discussion in #2370, the amended "Rule 2" is
  "when having a division followed by an implicit multiplication, the
   division gets higher precedence over the implicit multiplication when
   (a) the numerator is a constant with optionally a
       prefix operator (-, +, ~), and
   (b) the denominator is a constant."
  This commit implements that behavior and adds tests for it.
  Resolves #2370.

* fix: OperatorNode.toString() outputs match implicit multiplication parsing

  Also greatly extends the tests on OperatorNode.toString() and .toTex(), and
  ensures that all tests are performed on both. (toHTML() is still a testing
  stepchild.)
  Also fixes other small bugs in .toString() and .toTex() revealed by the
  new tests.
  Resolves #1431.

* test(parse): More cases of implicit multiplication

* refactor: Alter the precedence of implicit multiplication

  This greatly simplifies OperatorNode:calculateNecessaryParentheses,
  as opposed to trying to correct for the change in precedence after
  the fact.

* Fix broken unit test

* Replace `options && options.implicit` with `options?.implicit`

* Replace `options?.implicit` with `options && options.implicit` again, it breaks the Node 12 tests

* chore: Prevent confusion with standard matrix functions. (#2465)

* chore: Prevent consfusion with standard matrix functions.

  Prior to this commit, many functions operated elementwise on matrices
  even though in standard mathematical usage they have a different
  meaning on square matrices. Since the elementwise operation is easily
  recoverable using `math.map`, this commit removes the elementwise
  operation on arrays and matrices from these functions.
  Affected functions include all trigonometric functions, exp, log, gamma,
  square, sqrt, cube, and cbrt.
  Resolves #2440.

* chore(typescript): Revise usages in light of changes

  sqrt() is now correctly typed as `number | Complex` and so must
  be explicitly cast to number when called on a positive and used
  where a Complex is disallowed; sqrt() no longer applies to matrices
  at all.

* feat: Provide better error messages for v10 -> v11 transition

  Uses new `typed.onMismatch` handler so that matrix calls that used to
  work will suggest a replacement.

* Fix #2412: let function diff return an empty matrix when the input contains only one element (#2422)

* Fix #2412: let function diff return an empty matrix when the input has only one element

* Undo changes in History in this fixme

* Add TypeScript definitions for src/utils/is.js (#2432)

This is a first step toward full publication of these functions,
that were already being exported by mathjs but had not yet
had the associated actions (documentation/available in 
parser/typed, etc.) Also, makes most of them into TypeScript
type guards, and adds Matrix as a constructor type. Resolved #2431.

Co-authored-by: Glen Whitney <glen@studioinfinity.org>

* test: add two-dimensional test cases for diff of length 1

Co-authored-by: Chris Chudzicki <christopher.chudzicki@gmail.com>
Co-authored-by: Glen Whitney <glen@studioinfinity.org>

* Refactor/simplify core cleanup (#2490)

* refactor: don't simplify constants in simplifyCore

  Keeps the operation of simplifyCore cleanly separate from
  simplifyConstant.

* fix; handle multiple consecutive operations in simplifyCore()

   Also adds support for logical operators.
   Resolves #2484.

* feat: export simplifyConstant

  Now that simplifyCore does not do any constant folding, clients may
  wish to access that behavior via simplifyConstant. Moreover, exporting it
  makes it easier to use in custom rule lists for simplify().

  Also adds docs, embedded docs, and tests for simplifyConstant().

  Also fixes simplifyCore() on logical functions (they always return boolean,
  rather than "short-circuiting").

  Resolves #2459.

* refactor: Rename matrix algorithms to stay sane in next refactor

* refactor: Create a generator for boilerplate matrix versions of operations

  This reduces code length and duplication, and significantly reduces the
  number of instances of 'this' that will require replacement when moving on
  top of typed-function v3.

* refactor: add automatic conversion from string to Node

  Eliminates many `this` calls in src/function/algebra, which will help
  conversion to typed-function v3a.

  Also make `resolve` into a typed function so that it will now work
  on strings as well, and adds a test that it does.

* refactor: Use temporary conversions to simplify typed-function definitions

  Specifically, temporarily converting Object to Map eases the definition
  of 'simplify' and a new, generally ignored type 'identifier' (a subtype
  of 'string') with a temporary conversion to 'SymbolNode' simplifies the
  definition of 'derivative'.

  These refactors eliminate multiple instances of this, which will ease
  conversion to typed-function v3a.

* refactor: Speed up utils/is.js typeOf function

  In preparation for using it as the function selector for the Unit class.
  Also fixes the inconsistency between the `typed` type hierarchy
  'function' and typeOf returning 'Function' in favor of
  'function', again to minimize the special cases in typeOf

* feat(Unit): Add a method giving the (string name of the) type of the value

  E.g. `math.unit('5cm').valType()` returns `number`.

  Also uses this for an internal method that directly gives the number
  converter for a Unit.

  Also fixes lint errors from previous commit (not clean, I know, I forgot
  that build-and-test does not run lint).

  Adds tests for unit.valType()

* refactor: Eliminate hyperbolic functions operating on angles

  There is no mathematical meaning to a hyperbolic function operating on
  an angle (the proper units of its argument is actually area), and it
  eliminates a number of uses of `this`, so remove such arguments.

* refactor: Remove miscellaneous unnecessary typed-function this refs

* refactor: Adapt to typed-function v3a

  Mostly this involves replaceing instances of 'this' with used of (preferably)
  typed.referTo() or typed.referToSelf(). Some repeated batterns of boilerpolate
  signatures within different divisions of functions (bitwise, relational,
  trigonometry) were factored out into their own files and reused in several
  of the individual functions.

* tests: Only require that derivative tests mention the proper node type

* refactor: remove typed.ignore

* chore: Update to typed-function 3.0

  Also had to deal with new typing for `resolve()` in that it now accepts
  strings and Matrices; added tests for the new possibilities for `resolve()`,
  and eliminated empty comments from the Node representation of parsed
  strings as they can't really be doing anyone any good and they are a pain
  for testing.

  Also updates the TypeScript declarations and tests for `resolve()`

* chore: Object.hasOwn not supported in Node 14

  Also removes 'resolve' from the known failing doc tests, now that it handles
  strings.

* chore: Drop ES5 / IE 11 support.

* fix(types): Remove no-longer-implementd matrix overloads

* test(identifier): As requested in review item 2

* refactor(Unit): valType => valueType as per review item 3

* test(hasNumericValue): Test boolean arguments as per review item 4

* refactor(Node): Use class syntax rather than assigning prototypes

  This change simplifies the typeOf() function, because now all subclasses
  of Node have the expected constructor name.

  Also, reformats the documentation of the typeOf() function so that the
  doc test of that function will serve as an exhaustive test that the bundle
  returns the proper types.

* Prevent chain functions from matching stored value with a rest parameter (#2559)

* chore: Prevent confusion with standard matrix functions. (#2465)

* chore: Prevent consfusion with standard matrix functions.

  Prior to this commit, many functions operated elementwise on matrices
  even though in standard mathematical usage they have a different
  meaning on square matrices. Since the elementwise operation is easily
  recoverable using `math.map`, this commit removes the elementwise
  operation on arrays and matrices from these functions.
  Affected functions include all trigonometric functions, exp, log, gamma,
  square, sqrt, cube, and cbrt.
  Resolves #2440.

* chore(typescript): Revise usages in light of changes

  sqrt() is now correctly typed as `number | Complex` and so must
  be explicitly cast to number when called on a positive and used
  where a Complex is disallowed; sqrt() no longer applies to matrices
  at all.

* feat: Provide better error messages for v10 -> v11 transition

  Uses new `typed.onMismatch` handler so that matrix calls that used to
  work will suggest a replacement.

* fix: prevent chain from matching rest parameter with stored value

  Since the revised code needs the isTypedFunction predicate, switch to using
  the typed-function implementation for that throughout mathjs, rather than
  rolling our own here.

  Also adds a test that chain() no longer allows this kind of usage.

  Removes the two type declarations in types/index.d.ts that were allowing
  this sort of "split rest" call and added tests that such calls are
  forbidden.

  Adds to the chaining documentation page that such "split" calls are not
  allowed.

* chore: Refresh this PR to reflect underlying changes

  Also addresses the review request with a detailed comment on the
  correctness of a new code section.

  Note that it reverts some changes to the TypeScript signatures of the
  matrix functions ones() and zeros() -- they do not actually have a
  typed-function signature of two numbers and an optional format
  specifically for two dimensions. What they have is a single rest
  parameter, from which the format is extracted if present.

  Hence, due to the ban on breaking rest parameters, it is not
  valid to call math.chain(3).zeros(2) to make a 3-by-2 matrix of zeros,
  which seems like a perfectly valid ban as the division of the dimensions
  is very confusing; this should be written as math.chain([3,2]).zeros().
  The TypeScript signatures are fixed accordingly, along with the edge
  case of no arguments to ones() and zeros() at all, which does work to
  produce the "empty matrix".

* Unit test `typeOf` on the minified bundle (currently failing)

* Update AUTHORS

* Improve testing of typeOf on browser bundle (WIP)

* fix #2621: Module "mathjs" has no exported member "count" .ts(2305) (#2622)

* fix #2621: Module "mathjs" has no exported member "count" .ts(2305)

* feat: Update comments of  count

* feat: update the signature for count

* feat: add usage example for count and sum

* chore: Ensure type info remains in bundling

Co-authored-by: Glen Whitney <glen@studioinfinity.org>
Co-authored-by: Chris Chudzicki <christopher.chudzicki@gmail.com>
Co-authored-by: Hansuku <1556207795@qq.com>

AUTHORS

@@ -194,5 +194,7 @@ Shadman Kolahzary <shadman.ko@gmail.com>
 Laureen Beaudry <63020359+laureen-m@users.noreply.github.com>
 BOUYA Med. Salim <bouyasalim@gmail.com>
 Alexander <nukisman@gmail.com>
+FelixSelter <55546882+FelixSelter@users.noreply.github.com>
+Hansuku <1556207795@qq.com>
 
 # Generated by tools/update-authors.js

README.md

@@ -75,7 +75,7 @@ See the [Getting Started](https://mathjs.org/docs/getting_started.html) for a mo
 
 ## Browser support
 
-Math.js works on any ES5 compatible JavaScript engine: node.js, Chrome, Firefox, Safari, Edge, and IE11.
+Math.js works on any ES6 compatible JavaScript engine, including node.js, Chrome, Firefox, Safari, and Edge.
 
 
 ## Documentation

docs/core/chaining.md

@@ -39,3 +39,11 @@ a number of special functions:
    Executes `math.format(value)` onto the chain's value, returning
    a string representation of the value.
 
+Note that a "rest" or "..." parameter may not be broken across the value
+in the chain and a function call. For example
+
+```js
+math.chain(3).median(4,5).done() // throws error
+```
+
+does not compute the median of 3, 4, and 5.

docs/datatypes/units.md

@@ -250,6 +250,10 @@ Returns a clone of a unit represented in SI units. Works with units with or with
 Get a string representation of the unit. The function will
 determine the best fitting prefix for the unit.
 
+### unit.valType()
+Get the string name of the current type of the value of this Unit object, e.g.
+'number', 'BigNumber', etc.
+
 ## Unit reference
 
 This section lists all available units, prefixes, and physical constants. These can be used via the Unit object, or via `math.evaluate()`.

docs/expressions/algebra.md

@@ -27,6 +27,12 @@ console.log(simplified.toString())       // '3 * x'
 console.log(simplified.evaluate({x: 4})) // 12
 ```
 
+Among its other actions, calling `simplify()` on an expression will convert
+any functions that have operator equivalents to their operator form:
+```js
+console.log(math.simplify('multiply(x,3)').toString)  // '3 * x'
+```
+
 Note that `simplify` has an optional argument `scope` that allows the definitions of variables in the expression (as numeric values, or as further expressions) to be specified and used in the simplification, e.g. continuing the previous example,
 
 ```js

docs/expressions/syntax.md

@@ -47,7 +47,11 @@ math.evaluate('2 + 3 * 4')   // 14
 math.evaluate('(2 + 3) * 4') // 20
 ```
 
-The following operators are available:
+The following operators are available. Note that almost every operator listed
+also has a function form with identical meaning that can be used
+interchangeably. For example, `x+y` will always evaluate identically to
+`add(x,y)`. For a full list of the equivalences, see the section on
+Functions below.
 
 Operator    | Name                       | Syntax      | Associativity | Example               | Result
 ----------- | -------------------------- | ----------  | ------------- | --------------------- | ---------------
@@ -197,6 +201,46 @@ const parser = math.parser()
 parser.evaluate('f = typed({"number": f(x) = x ^ 2 - 5})')
 ```
 
+Finally, as mentioned above, there is a function form for nearly every one of
+the mathematical operator symbols. Moreover, for some associative operators,
+the corresponding function allows arbitrarily many arguments. The table below
+gives the full correspondence.
+
+Operator Expression  | Equivalent Function Expression
+---------------------|-------------------------------
+`a or b`             |`or(a,b)`
+`a xor b`            |`xor(a,b)`
+`a and b`            |`and(a,b)`
+`a \| b`             |`bitOr(a,b)`
+`a ^\| b`            |`bitXor(a,b)`
+`a & b`              |`bitAnd(a,b)`
+`a == b`             |`equal(a,b)`
+`a != b`             |`unequal(a,b)`
+`a < b`              |`smaller(a,b)`
+`a > b`              |`larger(a,b)`
+`a <= b`             |`smallerEq(a,b)`
+`a << 3`             |`leftShift(a,3)`
+`a >> 3`             |`rightArithShift(a,3)`
+`a >>> 3`            |`rightLogShift(a,3)`
+`u to cm`            |`to(u, cm)`
+`a + b + c + ...`    |`add(a,b,c,...)`
+`a - b`              |`subtract(a,b)`
+`a * b * c * ...`    |`multiply(a,b,c,...)`
+`A .* B`             |`dotMultiply(A,B)`
+`A ./ B`             |`dotDivide(A,B)`
+`a mod b`            |`mod(a,b)`
+`+a`                 |`unaryPlus(a)`
+`-a`                 |`unaryMinus(a)`
+`~a`                 |`bitNot(a)`
+`not a`              |`not(a)`
+`a^b`                |`pow(a,b)`
+`A .^ B`             |`dotPow(A,B)`
+`a!`                 |`factorial(a)`
+`A'`                 |`ctranspose(A)`
+
+Note that math.js embodies a preference for the operator forms, in that calling
+`simplify` (see [Algebra](./algebra.md)) converts any instances of the function
+form into the corresponding operator.
 
 ## Constants and variables
 

package.json

@@ -33,7 +33,7 @@
     "javascript-natural-sort": "^0.7.1",
     "seedrandom": "^3.0.5",
     "tiny-emitter": "^2.1.0",
-    "typed-function": "^2.1.0"
+    "typed-function": "^3.0.0"
   },
   "devDependencies": {
     "@babel/core": "7.18.6",
@@ -176,8 +176,5 @@
   "bugs": {
     "url": "https://github.com/josdejong/mathjs/issues"
   },
-  "browserslist": [
-    "IE 11"
-  ],
   "sideEffects": false
 }

src/core/create.js

@@ -1,4 +1,5 @@
 import './../utils/polyfills.js'
+import typedFunction from 'typed-function'
 import { deepFlatten, isLegacyFactory, values } from '../utils/object.js'
 import * as emitter from './../utils/emitter.js'
 import { importFactory } from './function/import.js'
@@ -206,6 +207,8 @@ export function create (factories, config) {
   function lazyTyped (...args) {
     return math.typed.apply(math.typed, args)
   }
+  lazyTyped.isTypedFunction = typedFunction.isTypedFunction
+
   const internalImport = importFactory(lazyTyped, load, math, importedFactories)
   math.import = internalImport
 

src/core/function/import.js

@@ -144,7 +144,7 @@ export function importFactory (typed, load, math, importedFactories) {
       })
     }
 
-    if (isTypedFunction(math[name]) && isTypedFunction(value)) {
+    if (typed.isTypedFunction(math[name]) && typed.isTypedFunction(value)) {
       if (options.override) {
         // give the typed function the right name
         value = typed(name, value.signatures)
@@ -280,7 +280,7 @@ export function importFactory (typed, load, math, importedFactories) {
         return instance
       }
 
-      if (isTypedFunction(existing) && isTypedFunction(instance)) {
+      if (typed.isTypedFunction(existing) && typed.isTypedFunction(instance)) {
         // merge the existing and new typed function
         return typed(existing, instance)
       }
@@ -344,15 +344,6 @@ export function importFactory (typed, load, math, importedFactories) {
         Array.isArray(object)
   }
 
-  /**
-   * Test whether a given thing is a typed-function
-   * @param {*} fn
-   * @return {boolean} Returns true when `fn` is a typed-function
-   */
-  function isTypedFunction (fn) {
-    return typeof fn === 'function' && typeof fn.signatures === 'object'
-  }
-
   function hasTypedFunctionSignature (fn) {
     return typeof fn === 'function' && typeof fn.signature === 'string'
   }

src/core/function/typed.js

@@ -45,6 +45,7 @@ import {
   isBlockNode,
   isBoolean,
   isChain,
+  isCollection,
   isComplex,
   isConditionalNode,
   isConstantNode,
@@ -109,12 +110,21 @@ export const createTyped = /* #__PURE__ */ factory('typed', dependencies, functi
   // define all types. The order of the types determines in which order function
   // arguments are type-checked (so for performance it's important to put the
   // most used types first).
-  typed.types = [
+  typed.clear()
+  typed.addTypes([
     { name: 'number', test: isNumber },
     { name: 'Complex', test: isComplex },
     { name: 'BigNumber', test: isBigNumber },
     { name: 'Fraction', test: isFraction },
     { name: 'Unit', test: isUnit },
+    // The following type matches a valid variable name, i.e., an alphanumeric
+    // string starting with an alphabetic character. It is used (at least)
+    // in the definition of the derivative() function, as the argument telling
+    // what to differentiate over must (currently) be a variable.
+    {
+      name: 'identifier',
+      test: s => isString && /^\p{L}[\p{L}\d]*$/u.test(s)
+    },
     { name: 'string', test: isString },
     { name: 'Chain', test: isChain },
     { name: 'Array', test: isArray },
@@ -150,9 +160,9 @@ export const createTyped = /* #__PURE__ */ factory('typed', dependencies, functi
 
     { name: 'Map', test: isMap },
     { name: 'Object', test: isObject } // order 'Object' last, it matches on other classes too
-  ]
+  ])
 
-  typed.conversions = [
+  typed.addConversions([
     {
       from: 'number',
       to: 'BigNumber',
@@ -179,12 +189,6 @@ export const createTyped = /* #__PURE__ */ factory('typed', dependencies, functi
 
         return new Complex(x, 0)
       }
-    }, {
-      from: 'number',
-      to: 'string',
-      convert: function (x) {
-        return x + ''
-      }
     }, {
       from: 'BigNumber',
       to: 'Complex',
@@ -336,7 +340,45 @@ export const createTyped = /* #__PURE__ */ factory('typed', dependencies, functi
         return matrix.valueOf()
       }
     }
-  ]
+  ])
+
+  // Provide a suggestion on how to call a function elementwise
+  // This was added primarily as guidance for the v10 -> v11 transition,
+  // and could potentially be removed in the future if it no longer seems
+  // to be helpful.
+  typed.onMismatch = (name, args, signatures) => {
+    const usualError = typed.createError(name, args, signatures)
+    if (['wrongType', 'mismatch'].includes(usualError.data.category) &&
+        args.length === 1 && isCollection(args[0]) &&
+        // check if the function can be unary:
+        signatures.some(sig => !sig.params.includes(','))) {
+      const err = new TypeError(
+        `Function '${name}' doesn't apply to matrices. To call it ` +
+          `elementwise on a matrix 'M', try 'map(M, ${name})'.`)
+      err.data = usualError.data
+      throw err
+    }
+    throw usualError
+  }
+
+  // Provide a suggestion on how to call a function elementwise
+  // This was added primarily as guidance for the v10 -> v11 transition,
+  // and could potentially be removed in the future if it no longer seems
+  // to be helpful.
+  typed.onMismatch = (name, args, signatures) => {
+    const usualError = typed.createError(name, args, signatures)
+    if (['wrongType', 'mismatch'].includes(usualError.data.category) &&
+        args.length === 1 && isCollection(args[0]) &&
+        // check if the function can be unary:
+        signatures.some(sig => !sig.params.includes(','))) {
+      const err = new TypeError(
+        `Function '${name}' doesn't apply to matrices. To call it ` +
+          `elementwise on a matrix 'M', try 'map(M, ${name})'.`)
+      err.data = usualError.data
+      throw err
+    }
+    throw usualError
+  }
 
   return typed
 })

src/expression/embeddedDocs/embeddedDocs.js

@@ -40,6 +40,7 @@ import { qrDocs } from './function/algebra/qr.js'
 import { rationalizeDocs } from './function/algebra/rationalize.js'
 import { resolveDocs } from './function/algebra/resolve.js'
 import { simplifyDocs } from './function/algebra/simplify.js'
+import { simplifyConstantDocs } from './function/algebra/simplifyConstant.js'
 import { simplifyCoreDocs } from './function/algebra/simplifyCore.js'
 import { sluDocs } from './function/algebra/slu.js'
 import { symbolicEqualDocs } from './function/algebra/symbolicEqual.js'
@@ -338,6 +339,7 @@ export const embeddedDocs = {
   leafCount: leafCountDocs,
   resolve: resolveDocs,
   simplify: simplifyDocs,
+  simplifyConstant: simplifyConstantDocs,
   simplifyCore: simplifyCoreDocs,
   symbolicEqual: symbolicEqualDocs,
   rationalize: rationalizeDocs,

src/expression/embeddedDocs/function/algebra/simplifyConstant.js

@@ -0,0 +1,16 @@
+export const simplifyConstantDocs = {
+  name: 'simplifyConstant',
+  category: 'Algebra',
+  syntax: [
+    'simplifyConstant(expr)',
+    'simplifyConstant(expr, options)'
+  ],
+  description: 'Replace constant subexpressions of node with their values.',
+  examples: [
+    'simplifyConatant("(3-3)*x")',
+    'simplifyConstant(parse("z-cos(tau/8)"))'
+  ],
+  seealso: [
+    'simplify', 'simplifyCore', 'evaluate'
+  ]
+}

src/expression/embeddedDocs/function/algebra/simplifyCore.js

@@ -10,6 +10,6 @@ export const simplifyCoreDocs = {
     'simplifyCore(parse("(x+0)*2"))'
   ],
   seealso: [
-    'simplify', 'evaluate'
+    'simplify', 'simplifyConstant', 'evaluate'
   ]
 }