simple-squiggle

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

solveValidation.js (3633B)

      1 import { isArray, isMatrix, isDenseMatrix, isSparseMatrix } from '../../../../utils/is.js';
      2 import { arraySize } from '../../../../utils/array.js';
      3 import { format } from '../../../../utils/string.js';
      4 export function createSolveValidation(_ref) {
      5   var {
      6     DenseMatrix
      7   } = _ref;
      8 
      9   /**
     10    * Validates matrix and column vector b for backward/forward substitution algorithms.
     11    *
     12    * @param {Matrix} m            An N x N matrix
     13    * @param {Array | Matrix} b    A column vector
     14    * @param {Boolean} copy        Return a copy of vector b
     15    *
     16    * @return {DenseMatrix}        Dense column vector b
     17    */
     18   return function solveValidation(m, b, copy) {
     19     var mSize = m.size();
     20 
     21     if (mSize.length !== 2) {
     22       throw new RangeError('Matrix must be two dimensional (size: ' + format(mSize) + ')');
     23     }
     24 
     25     var rows = mSize[0];
     26     var columns = mSize[1];
     27 
     28     if (rows !== columns) {
     29       throw new RangeError('Matrix must be square (size: ' + format(mSize) + ')');
     30     }
     31 
     32     var data = [];
     33 
     34     if (isMatrix(b)) {
     35       var bSize = b.size();
     36       var bdata = b._data; // 1-dim vector
     37 
     38       if (bSize.length === 1) {
     39         if (bSize[0] !== rows) {
     40           throw new RangeError('Dimension mismatch. Matrix columns must match vector length.');
     41         }
     42 
     43         for (var i = 0; i < rows; i++) {
     44           data[i] = [bdata[i]];
     45         }
     46 
     47         return new DenseMatrix({
     48           data: data,
     49           size: [rows, 1],
     50           datatype: b._datatype
     51         });
     52       } // 2-dim column
     53 
     54 
     55       if (bSize.length === 2) {
     56         if (bSize[0] !== rows || bSize[1] !== 1) {
     57           throw new RangeError('Dimension mismatch. Matrix columns must match vector length.');
     58         }
     59 
     60         if (isDenseMatrix(b)) {
     61           if (copy) {
     62             data = [];
     63 
     64             for (var _i = 0; _i < rows; _i++) {
     65               data[_i] = [bdata[_i][0]];
     66             }
     67 
     68             return new DenseMatrix({
     69               data: data,
     70               size: [rows, 1],
     71               datatype: b._datatype
     72             });
     73           }
     74 
     75           return b;
     76         }
     77 
     78         if (isSparseMatrix(b)) {
     79           for (var _i2 = 0; _i2 < rows; _i2++) {
     80             data[_i2] = [0];
     81           }
     82 
     83           var values = b._values;
     84           var index = b._index;
     85           var ptr = b._ptr;
     86 
     87           for (var k1 = ptr[1], k = ptr[0]; k < k1; k++) {
     88             var _i3 = index[k];
     89             data[_i3][0] = values[k];
     90           }
     91 
     92           return new DenseMatrix({
     93             data: data,
     94             size: [rows, 1],
     95             datatype: b._datatype
     96           });
     97         }
     98       }
     99 
    100       throw new RangeError('Dimension mismatch. The right side has to be either 1- or 2-dimensional vector.');
    101     }
    102 
    103     if (isArray(b)) {
    104       var bsize = arraySize(b);
    105 
    106       if (bsize.length === 1) {
    107         if (bsize[0] !== rows) {
    108           throw new RangeError('Dimension mismatch. Matrix columns must match vector length.');
    109         }
    110 
    111         for (var _i4 = 0; _i4 < rows; _i4++) {
    112           data[_i4] = [b[_i4]];
    113         }
    114 
    115         return new DenseMatrix({
    116           data: data,
    117           size: [rows, 1]
    118         });
    119       }
    120 
    121       if (bsize.length === 2) {
    122         if (bsize[0] !== rows || bsize[1] !== 1) {
    123           throw new RangeError('Dimension mismatch. Matrix columns must match vector length.');
    124         }
    125 
    126         for (var _i5 = 0; _i5 < rows; _i5++) {
    127           data[_i5] = [b[_i5][0]];
    128         }
    129 
    130         return new DenseMatrix({
    131           data: data,
    132           size: [rows, 1]
    133         });
    134       }
    135 
    136       throw new RangeError('Dimension mismatch. The right side has to be either 1- or 2-dimensional vector.');
    137     }
    138   };
    139 }