simple-squiggle

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

dotMultiply.js (3622B)

      1 import { factory } from '../../utils/factory.js';
      2 import { createAlgorithm02 } from '../../type/matrix/utils/algorithm02.js';
      3 import { createAlgorithm09 } from '../../type/matrix/utils/algorithm09.js';
      4 import { createAlgorithm11 } from '../../type/matrix/utils/algorithm11.js';
      5 import { createAlgorithm13 } from '../../type/matrix/utils/algorithm13.js';
      6 import { createAlgorithm14 } from '../../type/matrix/utils/algorithm14.js';
      7 var name = 'dotMultiply';
      8 var dependencies = ['typed', 'matrix', 'equalScalar', 'multiplyScalar'];
      9 export var createDotMultiply = /* #__PURE__ */factory(name, dependencies, _ref => {
     10   var {
     11     typed,
     12     matrix,
     13     equalScalar,
     14     multiplyScalar
     15   } = _ref;
     16   var algorithm02 = createAlgorithm02({
     17     typed,
     18     equalScalar
     19   });
     20   var algorithm09 = createAlgorithm09({
     21     typed,
     22     equalScalar
     23   });
     24   var algorithm11 = createAlgorithm11({
     25     typed,
     26     equalScalar
     27   });
     28   var algorithm13 = createAlgorithm13({
     29     typed
     30   });
     31   var algorithm14 = createAlgorithm14({
     32     typed
     33   });
     34   /**
     35    * Multiply two matrices element wise. The function accepts both matrices and
     36    * scalar values.
     37    *
     38    * Syntax:
     39    *
     40    *    math.dotMultiply(x, y)
     41    *
     42    * Examples:
     43    *
     44    *    math.dotMultiply(2, 4) // returns 8
     45    *
     46    *    a = [[9, 5], [6, 1]]
     47    *    b = [[3, 2], [5, 2]]
     48    *
     49    *    math.dotMultiply(a, b) // returns [[27, 10], [30, 2]]
     50    *    math.multiply(a, b)    // returns [[52, 28], [23, 14]]
     51    *
     52    * See also:
     53    *
     54    *    multiply, divide, dotDivide
     55    *
     56    * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} x Left hand value
     57    * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} y Right hand value
     58    * @return {number | BigNumber | Fraction | Complex | Unit | Array | Matrix}                    Multiplication of `x` and `y`
     59    */
     60 
     61   return typed(name, {
     62     'any, any': multiplyScalar,
     63     'SparseMatrix, SparseMatrix': function SparseMatrixSparseMatrix(x, y) {
     64       return algorithm09(x, y, multiplyScalar, false);
     65     },
     66     'SparseMatrix, DenseMatrix': function SparseMatrixDenseMatrix(x, y) {
     67       return algorithm02(y, x, multiplyScalar, true);
     68     },
     69     'DenseMatrix, SparseMatrix': function DenseMatrixSparseMatrix(x, y) {
     70       return algorithm02(x, y, multiplyScalar, false);
     71     },
     72     'DenseMatrix, DenseMatrix': function DenseMatrixDenseMatrix(x, y) {
     73       return algorithm13(x, y, multiplyScalar);
     74     },
     75     'Array, Array': function ArrayArray(x, y) {
     76       // use matrix implementation
     77       return this(matrix(x), matrix(y)).valueOf();
     78     },
     79     'Array, Matrix': function ArrayMatrix(x, y) {
     80       // use matrix implementation
     81       return this(matrix(x), y);
     82     },
     83     'Matrix, Array': function MatrixArray(x, y) {
     84       // use matrix implementation
     85       return this(x, matrix(y));
     86     },
     87     'SparseMatrix, any': function SparseMatrixAny(x, y) {
     88       return algorithm11(x, y, multiplyScalar, false);
     89     },
     90     'DenseMatrix, any': function DenseMatrixAny(x, y) {
     91       return algorithm14(x, y, multiplyScalar, false);
     92     },
     93     'any, SparseMatrix': function anySparseMatrix(x, y) {
     94       return algorithm11(y, x, multiplyScalar, true);
     95     },
     96     'any, DenseMatrix': function anyDenseMatrix(x, y) {
     97       return algorithm14(y, x, multiplyScalar, true);
     98     },
     99     'Array, any': function ArrayAny(x, y) {
    100       // use matrix implementation
    101       return algorithm14(matrix(x), y, multiplyScalar, false).valueOf();
    102     },
    103     'any, Array': function anyArray(x, y) {
    104       // use matrix implementation
    105       return algorithm14(matrix(y), x, multiplyScalar, true).valueOf();
    106     }
    107   });
    108 });