simple-squiggle

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

transpose.js (4497B)

      1 "use strict";
      2 
      3 Object.defineProperty(exports, "__esModule", {
      4   value: true
      5 });
      6 exports.createTranspose = void 0;
      7 
      8 var _object = require("../../utils/object.js");
      9 
     10 var _string = require("../../utils/string.js");
     11 
     12 var _factory = require("../../utils/factory.js");
     13 
     14 var name = 'transpose';
     15 var dependencies = ['typed', 'matrix'];
     16 var createTranspose = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
     17   var typed = _ref.typed,
     18       matrix = _ref.matrix;
     19 
     20   /**
     21    * Transpose a matrix. All values of the matrix are reflected over its
     22    * main diagonal. Only applicable to two dimensional matrices containing
     23    * a vector (i.e. having size `[1,n]` or `[n,1]`). One dimensional
     24    * vectors and scalars return the input unchanged.
     25    *
     26    * Syntax:
     27    *
     28    *     math.transpose(x)
     29    *
     30    * Examples:
     31    *
     32    *     const A = [[1, 2, 3], [4, 5, 6]]
     33    *     math.transpose(A)               // returns [[1, 4], [2, 5], [3, 6]]
     34    *
     35    * See also:
     36    *
     37    *     diag, inv, subset, squeeze
     38    *
     39    * @param {Array | Matrix} x  Matrix to be transposed
     40    * @return {Array | Matrix}   The transposed matrix
     41    */
     42   return typed('transpose', {
     43     Array: function Array(x) {
     44       // use dense matrix implementation
     45       return this(matrix(x)).valueOf();
     46     },
     47     Matrix: function Matrix(x) {
     48       // matrix size
     49       var size = x.size(); // result
     50 
     51       var c; // process dimensions
     52 
     53       switch (size.length) {
     54         case 1:
     55           // vector
     56           c = x.clone();
     57           break;
     58 
     59         case 2:
     60           {
     61             // rows and columns
     62             var rows = size[0];
     63             var columns = size[1]; // check columns
     64 
     65             if (columns === 0) {
     66               // throw exception
     67               throw new RangeError('Cannot transpose a 2D matrix with no columns (size: ' + (0, _string.format)(size) + ')');
     68             } // process storage format
     69 
     70 
     71             switch (x.storage()) {
     72               case 'dense':
     73                 c = _denseTranspose(x, rows, columns);
     74                 break;
     75 
     76               case 'sparse':
     77                 c = _sparseTranspose(x, rows, columns);
     78                 break;
     79             }
     80           }
     81           break;
     82 
     83         default:
     84           // multi dimensional
     85           throw new RangeError('Matrix must be a vector or two dimensional (size: ' + (0, _string.format)(this._size) + ')');
     86       }
     87 
     88       return c;
     89     },
     90     // scalars
     91     any: function any(x) {
     92       return (0, _object.clone)(x);
     93     }
     94   });
     95 
     96   function _denseTranspose(m, rows, columns) {
     97     // matrix array
     98     var data = m._data; // transposed matrix data
     99 
    100     var transposed = [];
    101     var transposedRow; // loop columns
    102 
    103     for (var j = 0; j < columns; j++) {
    104       // initialize row
    105       transposedRow = transposed[j] = []; // loop rows
    106 
    107       for (var i = 0; i < rows; i++) {
    108         // set data
    109         transposedRow[i] = (0, _object.clone)(data[i][j]);
    110       }
    111     } // return matrix
    112 
    113 
    114     return m.createDenseMatrix({
    115       data: transposed,
    116       size: [columns, rows],
    117       datatype: m._datatype
    118     });
    119   }
    120 
    121   function _sparseTranspose(m, rows, columns) {
    122     // matrix arrays
    123     var values = m._values;
    124     var index = m._index;
    125     var ptr = m._ptr; // result matrices
    126 
    127     var cvalues = values ? [] : undefined;
    128     var cindex = [];
    129     var cptr = []; // row counts
    130 
    131     var w = [];
    132 
    133     for (var x = 0; x < rows; x++) {
    134       w[x] = 0;
    135     } // vars
    136 
    137 
    138     var p, l, j; // loop values in matrix
    139 
    140     for (p = 0, l = index.length; p < l; p++) {
    141       // number of values in row
    142       w[index[p]]++;
    143     } // cumulative sum
    144 
    145 
    146     var sum = 0; // initialize cptr with the cummulative sum of row counts
    147 
    148     for (var i = 0; i < rows; i++) {
    149       // update cptr
    150       cptr.push(sum); // update sum
    151 
    152       sum += w[i]; // update w
    153 
    154       w[i] = cptr[i];
    155     } // update cptr
    156 
    157 
    158     cptr.push(sum); // loop columns
    159 
    160     for (j = 0; j < columns; j++) {
    161       // values & index in column
    162       for (var k0 = ptr[j], k1 = ptr[j + 1], k = k0; k < k1; k++) {
    163         // C values & index
    164         var q = w[index[k]]++; // C[j, i] = A[i, j]
    165 
    166         cindex[q] = j; // check we need to process values (pattern matrix)
    167 
    168         if (values) {
    169           cvalues[q] = (0, _object.clone)(values[k]);
    170         }
    171       }
    172     } // return matrix
    173 
    174 
    175     return m.createSparseMatrix({
    176       values: cvalues,
    177       index: cindex,
    178       ptr: cptr,
    179       size: [columns, rows],
    180       datatype: m._datatype
    181     });
    182   }
    183 });
    184 exports.createTranspose = createTranspose;