simple-squiggle

A restricted subset of Squiggle
Log | Files | Refs | README

matrixFromFunction.js (3020B)

      1 "use strict";
      2 
      3 Object.defineProperty(exports, "__esModule", {
      4   value: true
      5 });
      6 exports.createMatrixFromFunction = void 0;
      7 
      8 var _factory = require("../../utils/factory.js");
      9 
     10 var name = 'matrixFromFunction';
     11 var dependencies = ['typed', 'matrix', 'isZero'];
     12 var createMatrixFromFunction = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
     13   var typed = _ref.typed,
     14       matrix = _ref.matrix,
     15       isZero = _ref.isZero;
     16 
     17   /**
     18    * Create a matrix by evaluating a generating function at each index.
     19    * The simplest overload returns a multi-dimensional array as long as `size` is an array.
     20    * Passing `size` as a Matrix or specifying a `format` will result in returning a Matrix.
     21    *
     22    * Syntax:
     23    *
     24    *    math.matrixFromFunction(size, fn)
     25    *    math.matrixFromFunction(size, fn, format)
     26    *    math.matrixFromFunction(size, fn, format, datatype)
     27    *    math.matrixFromFunction(size, format, fn)
     28    *    math.matrixFromFunction(size, format, datatype, fn)
     29    *
     30    * Examples:
     31    *
     32    *    math.matrixFromFunction([3,3], i => i[0] - i[1]) // an antisymmetric matrix
     33    *    math.matrixFromFunction([100, 100], 'sparse', i => i[0] - i[1] === 1 ? 4 : 0) // a sparse subdiagonal matrix
     34    *    math.matrixFromFunction([5], i => math.random()) // a random vector
     35    *
     36    * See also:
     37    *
     38    *    matrix, zeros
     39    *
     40    * @param {Array | Matrix} size   The size of the matrix to be created
     41    * @param {function} fn           Callback function invoked for every entry in the matrix
     42    * @param {string} [format]       The Matrix storage format, either `'dense'` or `'sparse'`
     43    * @param {string} [datatype]     Type of the values
     44    * @return {Array | Matrix} Returns the created matrix
     45    */
     46   return typed(name, {
     47     'Array | Matrix, function, string, string': function ArrayMatrixFunctionStringString(size, fn, format, datatype) {
     48       return _create(size, fn, format, datatype);
     49     },
     50     'Array | Matrix, function, string': function ArrayMatrixFunctionString(size, fn, format) {
     51       return _create(size, fn, format);
     52     },
     53     'Matrix, function': function MatrixFunction(size, fn) {
     54       return _create(size, fn, 'dense');
     55     },
     56     'Array, function': function ArrayFunction(size, fn) {
     57       return _create(size, fn, 'dense').toArray();
     58     },
     59     'Array | Matrix, string, function': function ArrayMatrixStringFunction(size, format, fn) {
     60       return _create(size, fn, format);
     61     },
     62     'Array | Matrix, string, string, function': function ArrayMatrixStringStringFunction(size, format, datatype, fn) {
     63       return _create(size, fn, format, datatype);
     64     }
     65   });
     66 
     67   function _create(size, fn, format, datatype) {
     68     var m;
     69 
     70     if (datatype !== undefined) {
     71       m = matrix(format, datatype);
     72     } else {
     73       m = matrix(format);
     74     }
     75 
     76     m.resize(size);
     77     m.forEach(function (_, index) {
     78       var val = fn(index);
     79       if (isZero(val)) return;
     80       m.set(index, val);
     81     });
     82     return m;
     83   }
     84 });
     85 exports.createMatrixFromFunction = createMatrixFromFunction;