mathjs 10.6.4 → 11.0.0

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

@@ -5,6 +5,7 @@ import { clone, deepStrictEqual } from '../../utils/object.js';
 import { arraySize, getArrayDataType, processSizesWildcard, unsqueeze, validateIndex } from '../../utils/array.js';
 import { factory } from '../../utils/factory.js';
 import { DimensionError } from '../../error/DimensionError.js';
+import { maxArgumentCount } from '../../utils/function.js';
 var name = 'SparseMatrix';
 var dependencies = ['typed', 'equalScalar', 'Matrix'];
 export var createSparseMatrixClass = /* #__PURE__ */factory(name, dependencies, _ref => {
@@ -166,6 +167,10 @@ export var createSparseMatrixClass = /* #__PURE__ */factory(name, dependencies,
    */
 
 
+  Object.defineProperty(SparseMatrix, 'name', {
+    value: 'SparseMatrix'
+  });
+  SparseMatrix.prototype.constructor = SparseMatrix;
   SparseMatrix.prototype.type = 'SparseMatrix';
   SparseMatrix.prototype.isSparseMatrix = true;
   /**
@@ -919,8 +924,12 @@ export var createSparseMatrixClass = /* #__PURE__ */factory(name, dependencies,
     var rows = this._size[0];
     var columns = this._size[1]; // invoke callback
 
+    var args = maxArgumentCount(callback);
+
     var invoke = function invoke(v, i, j) {
       // invoke callback
+      if (args === 1) return callback(v);
+      if (args === 2) return callback(v, [i, j]);
       return callback(v, [i, j], me);
     }; // invoke _map
 

package/lib/esm/type/matrix/utils/{algorithm01.js → matAlgo01xDSid.js}

@@ -1,8 +1,8 @@
 import { factory } from '../../../utils/factory.js';
 import { DimensionError } from '../../../error/DimensionError.js';
-var name = 'algorithm01';
+var name = 'matAlgo01xDSid';
 var dependencies = ['typed'];
-export var createAlgorithm01 = /* #__PURE__ */factory(name, dependencies, _ref => {
+export var createMatAlgo01xDSid = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed
   } = _ref;

package/lib/esm/type/matrix/utils/{algorithm02.js → matAlgo02xDS0.js}

@@ -1,8 +1,8 @@
 import { factory } from '../../../utils/factory.js';
 import { DimensionError } from '../../../error/DimensionError.js';
-var name = 'algorithm02';
+var name = 'matAlgo02xDS0';
 var dependencies = ['typed', 'equalScalar'];
-export var createAlgorithm02 = /* #__PURE__ */factory(name, dependencies, _ref => {
+export var createMatAlgo02xDS0 = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     equalScalar
@@ -27,7 +27,7 @@ export var createAlgorithm02 = /* #__PURE__ */factory(name, dependencies, _ref =
    *
    * see https://github.com/josdejong/mathjs/pull/346#issuecomment-97477571
    */
-  return function algorithm02(denseMatrix, sparseMatrix, callback, inverse) {
+  return function matAlgo02xDS0(denseMatrix, sparseMatrix, callback, inverse) {
     // dense matrix arrays
     var adata = denseMatrix._data;
     var asize = denseMatrix._size;

package/lib/esm/type/matrix/utils/{algorithm03.js → matAlgo03xDSf.js}

@@ -1,8 +1,8 @@
 import { factory } from '../../../utils/factory.js';
 import { DimensionError } from '../../../error/DimensionError.js';
-var name = 'algorithm03';
+var name = 'matAlgo03xDSf';
 var dependencies = ['typed'];
-export var createAlgorithm03 = /* #__PURE__ */factory(name, dependencies, _ref => {
+export var createMatAlgo03xDSf = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed
   } = _ref;
@@ -26,7 +26,7 @@ export var createAlgorithm03 = /* #__PURE__ */factory(name, dependencies, _ref =
    *
    * see https://github.com/josdejong/mathjs/pull/346#issuecomment-97477571
    */
-  return function algorithm03(denseMatrix, sparseMatrix, callback, inverse) {
+  return function matAlgo03xDSf(denseMatrix, sparseMatrix, callback, inverse) {
     // dense matrix arrays
     var adata = denseMatrix._data;
     var asize = denseMatrix._size;

package/lib/esm/type/matrix/utils/{algorithm04.js → matAlgo04xSidSid.js}

@@ -1,8 +1,8 @@
 import { factory } from '../../../utils/factory.js';
 import { DimensionError } from '../../../error/DimensionError.js';
-var name = 'algorithm04';
+var name = 'matAlgo04xSidSid';
 var dependencies = ['typed', 'equalScalar'];
-export var createAlgorithm04 = /* #__PURE__ */factory(name, dependencies, _ref => {
+export var createMatAlgo04xSidSid = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     equalScalar
@@ -14,8 +14,8 @@ export var createAlgorithm04 = /* #__PURE__ */factory(name, dependencies, _ref =
    *
    *
    *          ┌  f(Aij, Bij)  ; A(i,j) !== 0 && B(i,j) !== 0
-   * C(i,j) = ┤  A(i,j)       ; A(i,j) !== 0
-   *          └  B(i,j)       ; B(i,j) !== 0
+   * C(i,j) = ┤  A(i,j)       ; A(i,j) !== 0 && B(i,j) === 0
+   *          └  B(i,j)       ; A(i,j) === 0
    *
    *
    * @param {Matrix}   a                 The SparseMatrix instance (A)
@@ -26,7 +26,7 @@ export var createAlgorithm04 = /* #__PURE__ */factory(name, dependencies, _ref =
    *
    * see https://github.com/josdejong/mathjs/pull/346#issuecomment-97620294
    */
-  return function algorithm04(a, b, callback) {
+  return function matAlgo04xSidSid(a, b, callback) {
     // sparse matrix arrays
     var avalues = a._values;
     var aindex = a._index;

package/lib/esm/type/matrix/utils/{algorithm05.js → matAlgo05xSfSf.js}

@@ -1,8 +1,8 @@
 import { factory } from '../../../utils/factory.js';
 import { DimensionError } from '../../../error/DimensionError.js';
-var name = 'algorithm05';
+var name = 'matAlgo05xSfSf';
 var dependencies = ['typed', 'equalScalar'];
-export var createAlgorithm05 = /* #__PURE__ */factory(name, dependencies, _ref => {
+export var createMatAlgo05xSfSf = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     equalScalar
@@ -26,7 +26,7 @@ export var createAlgorithm05 = /* #__PURE__ */factory(name, dependencies, _ref =
    *
    * see https://github.com/josdejong/mathjs/pull/346#issuecomment-97620294
    */
-  return function algorithm05(a, b, callback) {
+  return function matAlgo05xSfSf(a, b, callback) {
     // sparse matrix arrays
     var avalues = a._values;
     var aindex = a._index;

package/lib/esm/type/matrix/utils/{algorithm06.js → matAlgo06xS0S0.js}

@@ -1,9 +1,9 @@
 import { factory } from '../../../utils/factory.js';
 import { DimensionError } from '../../../error/DimensionError.js';
 import { scatter } from '../../../utils/collection.js';
-var name = 'algorithm06';
+var name = 'matAlgo06xS0S0';
 var dependencies = ['typed', 'equalScalar'];
-export var createAlgorithm06 = /* #__PURE__ */factory(name, dependencies, _ref => {
+export var createMatAlgo06xS0S0 = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     equalScalar
@@ -27,7 +27,7 @@ export var createAlgorithm06 = /* #__PURE__ */factory(name, dependencies, _ref =
    *
    * see https://github.com/josdejong/mathjs/pull/346#issuecomment-97620294
    */
-  return function algorithm06(a, b, callback) {
+  return function matAlgo06xS0S0(a, b, callback) {
     // sparse matrix arrays
     var avalues = a._values;
     var asize = a._size;

package/lib/esm/type/matrix/utils/{algorithm07.js → matAlgo07xSSf.js}

@@ -1,8 +1,8 @@
 import { factory } from '../../../utils/factory.js';
 import { DimensionError } from '../../../error/DimensionError.js';
-var name = 'algorithm07';
+var name = 'matAlgo07xSSf';
 var dependencies = ['typed', 'DenseMatrix'];
-export var createAlgorithm07 = /* #__PURE__ */factory(name, dependencies, _ref => {
+export var createMatAlgo07xSSf = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     DenseMatrix
@@ -22,7 +22,7 @@ export var createAlgorithm07 = /* #__PURE__ */factory(name, dependencies, _ref =
    *
    * see https://github.com/josdejong/mathjs/pull/346#issuecomment-97620294
    */
-  return function algorithm07(a, b, callback) {
+  return function matAlgo07xSSf(a, b, callback) {
     // sparse matrix arrays
     var asize = a._size;
     var adt = a._datatype; // sparse matrix arrays

package/lib/esm/type/matrix/utils/{algorithm08.js → matAlgo08xS0Sid.js}

@@ -1,8 +1,8 @@
 import { factory } from '../../../utils/factory.js';
 import { DimensionError } from '../../../error/DimensionError.js';
-var name = 'algorithm08';
+var name = 'matAlgo08xS0Sid';
 var dependencies = ['typed', 'equalScalar'];
-export var createAlgorithm08 = /* #__PURE__ */factory(name, dependencies, _ref => {
+export var createMatAlgo08xS0Sid = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     equalScalar
@@ -14,7 +14,7 @@ export var createAlgorithm08 = /* #__PURE__ */factory(name, dependencies, _ref =
    *
    *
    *          ┌  f(Aij, Bij)  ; A(i,j) !== 0 && B(i,j) !== 0
-   * C(i,j) = ┤  A(i,j)       ; A(i,j) !== 0
+   * C(i,j) = ┤  A(i,j)       ; A(i,j) !== 0 && B(i,j) === 0
    *          └  0            ; otherwise
    *
    *
@@ -26,7 +26,7 @@ export var createAlgorithm08 = /* #__PURE__ */factory(name, dependencies, _ref =
    *
    * see https://github.com/josdejong/mathjs/pull/346#issuecomment-97620294
    */
-  return function algorithm08(a, b, callback) {
+  return function matAlgo08xS0Sid(a, b, callback) {
     // sparse matrix arrays
     var avalues = a._values;
     var aindex = a._index;

package/lib/esm/type/matrix/utils/{algorithm09.js → matAlgo09xS0Sf.js}

@@ -1,8 +1,8 @@
 import { factory } from '../../../utils/factory.js';
 import { DimensionError } from '../../../error/DimensionError.js';
-var name = 'algorithm09';
+var name = 'matAlgo09xS0Sf';
 var dependencies = ['typed', 'equalScalar'];
-export var createAlgorithm09 = /* #__PURE__ */factory(name, dependencies, _ref => {
+export var createMatAlgo09xS0Sf = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     equalScalar
@@ -26,7 +26,7 @@ export var createAlgorithm09 = /* #__PURE__ */factory(name, dependencies, _ref =
    *
    * see https://github.com/josdejong/mathjs/pull/346#issuecomment-97620294
    */
-  return function algorithm09(a, b, callback) {
+  return function matAlgo09xS0Sf(a, b, callback) {
     // sparse matrix arrays
     var avalues = a._values;
     var aindex = a._index;

package/lib/esm/type/matrix/utils/{algorithm10.js → matAlgo10xSids.js}

@@ -1,7 +1,7 @@
 import { factory } from '../../../utils/factory.js';
-var name = 'algorithm10';
+var name = 'matAlgo10xSids';
 var dependencies = ['typed', 'DenseMatrix'];
-export var createAlgorithm10 = /* #__PURE__ */factory(name, dependencies, _ref => {
+export var createMatAlgo10xSids = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     DenseMatrix
@@ -26,7 +26,7 @@ export var createAlgorithm10 = /* #__PURE__ */factory(name, dependencies, _ref =
    *
    * https://github.com/josdejong/mathjs/pull/346#issuecomment-97626813
    */
-  return function algorithm10(s, b, callback, inverse) {
+  return function matAlgo10xSids(s, b, callback, inverse) {
     // sparse matrix arrays
     var avalues = s._values;
     var aindex = s._index;

package/lib/esm/type/matrix/utils/{algorithm11.js → matAlgo11xS0s.js}

@@ -1,7 +1,7 @@
 import { factory } from '../../../utils/factory.js';
-var name = 'algorithm11';
+var name = 'matAlgo11xS0s';
 var dependencies = ['typed', 'equalScalar'];
-export var createAlgorithm11 = /* #__PURE__ */factory(name, dependencies, _ref => {
+export var createMatAlgo11xS0s = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     equalScalar
@@ -26,7 +26,7 @@ export var createAlgorithm11 = /* #__PURE__ */factory(name, dependencies, _ref =
    *
    * https://github.com/josdejong/mathjs/pull/346#issuecomment-97626813
    */
-  return function algorithm11(s, b, callback, inverse) {
+  return function matAlgo11xS0s(s, b, callback, inverse) {
     // sparse matrix arrays
     var avalues = s._values;
     var aindex = s._index;

package/lib/esm/type/matrix/utils/{algorithm12.js → matAlgo12xSfs.js}

@@ -1,7 +1,7 @@
 import { factory } from '../../../utils/factory.js';
-var name = 'algorithm12';
+var name = 'matAlgo12xSfs';
 var dependencies = ['typed', 'DenseMatrix'];
-export var createAlgorithm12 = /* #__PURE__ */factory(name, dependencies, _ref => {
+export var createMatAlgo12xSfs = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     DenseMatrix
@@ -26,7 +26,7 @@ export var createAlgorithm12 = /* #__PURE__ */factory(name, dependencies, _ref =
    *
    * https://github.com/josdejong/mathjs/pull/346#issuecomment-97626813
    */
-  return function algorithm12(s, b, callback, inverse) {
+  return function matAlgo12xSfs(s, b, callback, inverse) {
     // sparse matrix arrays
     var avalues = s._values;
     var aindex = s._index;

package/lib/esm/type/matrix/utils/{algorithm13.js → matAlgo13xDD.js}

@@ -1,8 +1,8 @@
 import { factory } from '../../../utils/factory.js';
 import { DimensionError } from '../../../error/DimensionError.js';
-var name = 'algorithm13';
+var name = 'matAlgo13xDD';
 var dependencies = ['typed'];
-export var createAlgorithm13 = /* #__PURE__ */factory(name, dependencies, _ref => {
+export var createMatAlgo13xDD = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed
   } = _ref;
@@ -21,7 +21,7 @@ export var createAlgorithm13 = /* #__PURE__ */factory(name, dependencies, _ref =
    *
    * https://github.com/josdejong/mathjs/pull/346#issuecomment-97658658
    */
-  return function algorithm13(a, b, callback) {
+  return function matAlgo13xDD(a, b, callback) {
     // a arrays
     var adata = a._data;
     var asize = a._size;

package/lib/esm/type/matrix/utils/{algorithm14.js → matAlgo14xDs.js}

@@ -1,8 +1,8 @@
 import { factory } from '../../../utils/factory.js';
 import { clone } from '../../../utils/object.js';
-var name = 'algorithm14';
+var name = 'matAlgo14xDs';
 var dependencies = ['typed'];
-export var createAlgorithm14 = /* #__PURE__ */factory(name, dependencies, _ref => {
+export var createMatAlgo14xDs = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed
   } = _ref;
@@ -22,7 +22,7 @@ export var createAlgorithm14 = /* #__PURE__ */factory(name, dependencies, _ref =
    *
    * https://github.com/josdejong/mathjs/pull/346#issuecomment-97659042
    */
-  return function algorithm14(a, b, callback, inverse) {
+  return function matAlgo14xDs(a, b, callback, inverse) {
     // a arrays
     var adata = a._data;
     var asize = a._size;

package/lib/esm/type/matrix/utils/matrixAlgorithmSuite.js

@@ -0,0 +1,168 @@
+import { factory } from '../../../utils/factory.js';
+import { extend } from '../../../utils/object.js';
+import { createMatAlgo13xDD } from './matAlgo13xDD.js';
+import { createMatAlgo14xDs } from './matAlgo14xDs.js';
+var name = 'matrixAlgorithmSuite';
+var dependencies = ['typed', 'matrix'];
+export var createMatrixAlgorithmSuite = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    matrix
+  } = _ref;
+  var matAlgo13xDD = createMatAlgo13xDD({
+    typed
+  });
+  var matAlgo14xDs = createMatAlgo14xDs({
+    typed
+  });
+  /**
+   * Return a signatures object with the usual boilerplate of
+   * matrix algorithms, based on a plain options object with the
+   * following properties:
+   *   elop: function -- the elementwise operation to use, defaults to self
+   *   SS: function -- the algorithm to apply for two sparse matrices
+   *   DS: function -- the algorithm to apply for a dense and a sparse matrix
+   *   SD: function -- algo for a sparse and a dense; defaults to SD flipped
+   *   Ss: function -- the algorithm to apply for a sparse matrix and scalar
+   *   sS: function -- algo for scalar and sparse; defaults to Ss flipped
+   *   scalar: string -- typed-function type for scalars, defaults to 'any'
+   *
+   * If Ss is not specified, no matrix-scalar signatures are generated.
+   *
+   * @param {object} options
+   * @return {Object<string, function>} signatures
+   */
+
+  return function matrixAlgorithmSuite(options) {
+    var elop = options.elop;
+    var SD = options.SD || options.DS;
+    var matrixSignatures;
+
+    if (elop) {
+      // First the dense ones
+      matrixSignatures = {
+        'DenseMatrix, DenseMatrix': (x, y) => matAlgo13xDD(x, y, elop),
+        'Array, Array': (x, y) => matAlgo13xDD(matrix(x), matrix(y), elop).valueOf(),
+        'Array, DenseMatrix': (x, y) => matAlgo13xDD(matrix(x), y, elop),
+        'DenseMatrix, Array': (x, y) => matAlgo13xDD(x, matrix(y), elop)
+      }; // Now incorporate sparse matrices
+
+      if (options.SS) {
+        matrixSignatures['SparseMatrix, SparseMatrix'] = (x, y) => options.SS(x, y, elop, false);
+      }
+
+      if (options.DS) {
+        matrixSignatures['DenseMatrix, SparseMatrix'] = (x, y) => options.DS(x, y, elop, false);
+
+        matrixSignatures['Array, SparseMatrix'] = (x, y) => options.DS(matrix(x), y, elop, false);
+      }
+
+      if (SD) {
+        matrixSignatures['SparseMatrix, DenseMatrix'] = (x, y) => SD(y, x, elop, true);
+
+        matrixSignatures['SparseMatrix, Array'] = (x, y) => SD(matrix(y), x, elop, true);
+      }
+    } else {
+      // No elop, use this
+      // First the dense ones
+      matrixSignatures = {
+        'DenseMatrix, DenseMatrix': typed.referToSelf(self => (x, y) => {
+          return matAlgo13xDD(x, y, self);
+        }),
+        'Array, Array': typed.referToSelf(self => (x, y) => {
+          return matAlgo13xDD(matrix(x), matrix(y), self).valueOf();
+        }),
+        'Array, DenseMatrix': typed.referToSelf(self => (x, y) => {
+          return matAlgo13xDD(matrix(x), y, self);
+        }),
+        'DenseMatrix, Array': typed.referToSelf(self => (x, y) => {
+          return matAlgo13xDD(x, matrix(y), self);
+        })
+      }; // Now incorporate sparse matrices
+
+      if (options.SS) {
+        matrixSignatures['SparseMatrix, SparseMatrix'] = typed.referToSelf(self => (x, y) => {
+          return options.SS(x, y, self, false);
+        });
+      }
+
+      if (options.DS) {
+        matrixSignatures['DenseMatrix, SparseMatrix'] = typed.referToSelf(self => (x, y) => {
+          return options.DS(x, y, self, false);
+        });
+        matrixSignatures['Array, SparseMatrix'] = typed.referToSelf(self => (x, y) => {
+          return options.DS(matrix(x), y, self, false);
+        });
+      }
+
+      if (SD) {
+        matrixSignatures['SparseMatrix, DenseMatrix'] = typed.referToSelf(self => (x, y) => {
+          return SD(y, x, self, true);
+        });
+        matrixSignatures['SparseMatrix, Array'] = typed.referToSelf(self => (x, y) => {
+          return SD(matrix(y), x, self, true);
+        });
+      }
+    } // Now add the scalars
+
+
+    var scalar = options.scalar || 'any';
+    var Ds = options.Ds || options.Ss;
+
+    if (Ds) {
+      if (elop) {
+        matrixSignatures['DenseMatrix,' + scalar] = (x, y) => matAlgo14xDs(x, y, elop, false);
+
+        matrixSignatures[scalar + ', DenseMatrix'] = (x, y) => matAlgo14xDs(y, x, elop, true);
+
+        matrixSignatures['Array,' + scalar] = (x, y) => matAlgo14xDs(matrix(x), y, elop, false).valueOf();
+
+        matrixSignatures[scalar + ', Array'] = (x, y) => matAlgo14xDs(matrix(y), x, elop, true).valueOf();
+      } else {
+        matrixSignatures['DenseMatrix,' + scalar] = typed.referToSelf(self => (x, y) => {
+          return matAlgo14xDs(x, y, self, false);
+        });
+        matrixSignatures[scalar + ', DenseMatrix'] = typed.referToSelf(self => (x, y) => {
+          return matAlgo14xDs(y, x, self, true);
+        });
+        matrixSignatures['Array,' + scalar] = typed.referToSelf(self => (x, y) => {
+          return matAlgo14xDs(matrix(x), y, self, false).valueOf();
+        });
+        matrixSignatures[scalar + ', Array'] = typed.referToSelf(self => (x, y) => {
+          return matAlgo14xDs(matrix(y), x, self, true).valueOf();
+        });
+      }
+    }
+
+    var sS = options.sS !== undefined ? options.sS : options.Ss;
+
+    if (elop) {
+      if (options.Ss) {
+        matrixSignatures['SparseMatrix,' + scalar] = (x, y) => options.Ss(x, y, elop, false);
+      }
+
+      if (sS) {
+        matrixSignatures[scalar + ', SparseMatrix'] = (x, y) => sS(y, x, elop, true);
+      }
+    } else {
+      if (options.Ss) {
+        matrixSignatures['SparseMatrix,' + scalar] = typed.referToSelf(self => (x, y) => {
+          return options.Ss(x, y, self, false);
+        });
+      }
+
+      if (sS) {
+        matrixSignatures[scalar + ', SparseMatrix'] = typed.referToSelf(self => (x, y) => {
+          return sS(y, x, self, true);
+        });
+      }
+    } // Also pull in the scalar signatures if the operator is a typed function
+
+
+    if (elop && elop.signatures) {
+      extend(matrixSignatures, elop.signatures);
+    }
+
+    return matrixSignatures;
+  };
+});

package/lib/esm/type/number.js

@@ -146,9 +146,7 @@ export var createNumber = /* #__PURE__ */factory(name, dependencies, _ref => {
     'Unit, string | Unit': function UnitStringUnit(unit, valuelessUnit) {
       return unit.toNumber(valuelessUnit);
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return deepMap(x, this);
-    }
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
   }); // reviver function to parse a JSON object like:
   //
   //     {"mathjs":"number","value":"2.3"}

package/lib/esm/type/string.js

@@ -47,9 +47,7 @@ export var createString = /* #__PURE__ */factory(name, dependencies, _ref => {
     string: function string(x) {
       return x;
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return deepMap(x, this);
-    },
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self)),
     any: function any(x) {
       return String(x);
     }