1 | import { factory } from '../../utils/factory.js';
|
2 | import { isMatrix } from '../../utils/is.js';
|
3 | import { extend } from '../../utils/object.js';
|
4 | import { arraySize } from '../../utils/array.js';
|
5 | import { createAlgorithm11 } from '../../type/matrix/utils/algorithm11.js';
|
6 | import { createAlgorithm14 } from '../../type/matrix/utils/algorithm14.js';
|
7 | var name = 'multiply';
|
8 | var dependencies = ['typed', 'matrix', 'addScalar', 'multiplyScalar', 'equalScalar', 'dot'];
|
9 | export var createMultiply = factory(name, dependencies, (_ref) => {
|
10 | var {
|
11 | typed,
|
12 | matrix,
|
13 | addScalar,
|
14 | multiplyScalar,
|
15 | equalScalar,
|
16 | dot
|
17 | } = _ref;
|
18 | var algorithm11 = createAlgorithm11({
|
19 | typed,
|
20 | equalScalar
|
21 | });
|
22 | var algorithm14 = createAlgorithm14({
|
23 | typed
|
24 | });
|
25 |
|
26 | function _validateMatrixDimensions(size1, size2) {
|
27 |
|
28 | switch (size1.length) {
|
29 | case 1:
|
30 |
|
31 | switch (size2.length) {
|
32 | case 1:
|
33 |
|
34 | if (size1[0] !== size2[0]) {
|
35 |
|
36 | throw new RangeError('Dimension mismatch in multiplication. Vectors must have the same length');
|
37 | }
|
38 |
|
39 | break;
|
40 |
|
41 | case 2:
|
42 |
|
43 | if (size1[0] !== size2[0]) {
|
44 |
|
45 | throw new RangeError('Dimension mismatch in multiplication. Vector length (' + size1[0] + ') must match Matrix rows (' + size2[0] + ')');
|
46 | }
|
47 |
|
48 | break;
|
49 |
|
50 | default:
|
51 | throw new Error('Can only multiply a 1 or 2 dimensional matrix (Matrix B has ' + size2.length + ' dimensions)');
|
52 | }
|
53 |
|
54 | break;
|
55 |
|
56 | case 2:
|
57 |
|
58 | switch (size2.length) {
|
59 | case 1:
|
60 |
|
61 | if (size1[1] !== size2[0]) {
|
62 |
|
63 | throw new RangeError('Dimension mismatch in multiplication. Matrix columns (' + size1[1] + ') must match Vector length (' + size2[0] + ')');
|
64 | }
|
65 |
|
66 | break;
|
67 |
|
68 | case 2:
|
69 |
|
70 | if (size1[1] !== size2[0]) {
|
71 |
|
72 | throw new RangeError('Dimension mismatch in multiplication. Matrix A columns (' + size1[1] + ') must match Matrix B rows (' + size2[0] + ')');
|
73 | }
|
74 |
|
75 | break;
|
76 |
|
77 | default:
|
78 | throw new Error('Can only multiply a 1 or 2 dimensional matrix (Matrix B has ' + size2.length + ' dimensions)');
|
79 | }
|
80 |
|
81 | break;
|
82 |
|
83 | default:
|
84 | throw new Error('Can only multiply a 1 or 2 dimensional matrix (Matrix A has ' + size1.length + ' dimensions)');
|
85 | }
|
86 | }
|
87 | |
88 |
|
89 |
|
90 |
|
91 |
|
92 |
|
93 |
|
94 |
|
95 |
|
96 |
|
97 | function _multiplyVectorVector(a, b, n) {
|
98 |
|
99 | if (n === 0) {
|
100 | throw new Error('Cannot multiply two empty vectors');
|
101 | }
|
102 |
|
103 | return dot(a, b);
|
104 | }
|
105 | |
106 |
|
107 |
|
108 |
|
109 |
|
110 |
|
111 |
|
112 |
|
113 |
|
114 |
|
115 | function _multiplyVectorMatrix(a, b) {
|
116 |
|
117 | if (b.storage() !== 'dense') {
|
118 | throw new Error('Support for SparseMatrix not implemented');
|
119 | }
|
120 |
|
121 | return _multiplyVectorDenseMatrix(a, b);
|
122 | }
|
123 | |
124 |
|
125 |
|
126 |
|
127 |
|
128 |
|
129 |
|
130 |
|
131 |
|
132 |
|
133 | function _multiplyVectorDenseMatrix(a, b) {
|
134 |
|
135 | var adata = a._data;
|
136 | var asize = a._size;
|
137 | var adt = a._datatype;
|
138 |
|
139 | var bdata = b._data;
|
140 | var bsize = b._size;
|
141 | var bdt = b._datatype;
|
142 |
|
143 | var alength = asize[0];
|
144 | var bcolumns = bsize[1];
|
145 |
|
146 | var dt;
|
147 |
|
148 | var af = addScalar;
|
149 |
|
150 | var mf = multiplyScalar;
|
151 |
|
152 | if (adt && bdt && adt === bdt && typeof adt === 'string') {
|
153 |
|
154 | dt = adt;
|
155 |
|
156 | af = typed.find(addScalar, [dt, dt]);
|
157 | mf = typed.find(multiplyScalar, [dt, dt]);
|
158 | }
|
159 |
|
160 |
|
161 | var c = [];
|
162 |
|
163 | for (var j = 0; j < bcolumns; j++) {
|
164 |
|
165 | var sum = mf(adata[0], bdata[0][j]);
|
166 |
|
167 | for (var i = 1; i < alength; i++) {
|
168 |
|
169 | sum = af(sum, mf(adata[i], bdata[i][j]));
|
170 | }
|
171 |
|
172 | c[j] = sum;
|
173 | }
|
174 |
|
175 |
|
176 | return a.createDenseMatrix({
|
177 | data: c,
|
178 | size: [bcolumns],
|
179 | datatype: dt
|
180 | });
|
181 | }
|
182 | |
183 |
|
184 |
|
185 |
|
186 |
|
187 |
|
188 |
|
189 |
|
190 |
|
191 |
|
192 | var _multiplyMatrixVector = typed('_multiplyMatrixVector', {
|
193 | 'DenseMatrix, any': _multiplyDenseMatrixVector,
|
194 | 'SparseMatrix, any': _multiplySparseMatrixVector
|
195 | });
|
196 | |
197 |
|
198 |
|
199 |
|
200 |
|
201 |
|
202 |
|
203 |
|
204 |
|
205 |
|
206 | var _multiplyMatrixMatrix = typed('_multiplyMatrixMatrix', {
|
207 | 'DenseMatrix, DenseMatrix': _multiplyDenseMatrixDenseMatrix,
|
208 | 'DenseMatrix, SparseMatrix': _multiplyDenseMatrixSparseMatrix,
|
209 | 'SparseMatrix, DenseMatrix': _multiplySparseMatrixDenseMatrix,
|
210 | 'SparseMatrix, SparseMatrix': _multiplySparseMatrixSparseMatrix
|
211 | });
|
212 | |
213 |
|
214 |
|
215 |
|
216 |
|
217 |
|
218 |
|
219 |
|
220 |
|
221 |
|
222 | function _multiplyDenseMatrixVector(a, b) {
|
223 |
|
224 | var adata = a._data;
|
225 | var asize = a._size;
|
226 | var adt = a._datatype;
|
227 |
|
228 | var bdata = b._data;
|
229 | var bdt = b._datatype;
|
230 |
|
231 | var arows = asize[0];
|
232 | var acolumns = asize[1];
|
233 |
|
234 | var dt;
|
235 |
|
236 | var af = addScalar;
|
237 |
|
238 | var mf = multiplyScalar;
|
239 |
|
240 | if (adt && bdt && adt === bdt && typeof adt === 'string') {
|
241 |
|
242 | dt = adt;
|
243 |
|
244 | af = typed.find(addScalar, [dt, dt]);
|
245 | mf = typed.find(multiplyScalar, [dt, dt]);
|
246 | }
|
247 |
|
248 |
|
249 | var c = [];
|
250 |
|
251 | for (var i = 0; i < arows; i++) {
|
252 |
|
253 | var row = adata[i];
|
254 |
|
255 | var sum = mf(row[0], bdata[0]);
|
256 |
|
257 | for (var j = 1; j < acolumns; j++) {
|
258 |
|
259 | sum = af(sum, mf(row[j], bdata[j]));
|
260 | }
|
261 |
|
262 | c[i] = sum;
|
263 | }
|
264 |
|
265 |
|
266 | return a.createDenseMatrix({
|
267 | data: c,
|
268 | size: [arows],
|
269 | datatype: dt
|
270 | });
|
271 | }
|
272 | |
273 |
|
274 |
|
275 |
|
276 |
|
277 |
|
278 |
|
279 |
|
280 |
|
281 |
|
282 | function _multiplyDenseMatrixDenseMatrix(a, b) {
|
283 |
|
284 | var adata = a._data;
|
285 | var asize = a._size;
|
286 | var adt = a._datatype;
|
287 |
|
288 | var bdata = b._data;
|
289 | var bsize = b._size;
|
290 | var bdt = b._datatype;
|
291 |
|
292 | var arows = asize[0];
|
293 | var acolumns = asize[1];
|
294 | var bcolumns = bsize[1];
|
295 |
|
296 | var dt;
|
297 |
|
298 | var af = addScalar;
|
299 |
|
300 | var mf = multiplyScalar;
|
301 |
|
302 | if (adt && bdt && adt === bdt && typeof adt === 'string') {
|
303 |
|
304 | dt = adt;
|
305 |
|
306 | af = typed.find(addScalar, [dt, dt]);
|
307 | mf = typed.find(multiplyScalar, [dt, dt]);
|
308 | }
|
309 |
|
310 |
|
311 | var c = [];
|
312 |
|
313 | for (var i = 0; i < arows; i++) {
|
314 |
|
315 | var row = adata[i];
|
316 |
|
317 | c[i] = [];
|
318 |
|
319 | for (var j = 0; j < bcolumns; j++) {
|
320 |
|
321 | var sum = mf(row[0], bdata[0][j]);
|
322 |
|
323 | for (var x = 1; x < acolumns; x++) {
|
324 |
|
325 | sum = af(sum, mf(row[x], bdata[x][j]));
|
326 | }
|
327 |
|
328 | c[i][j] = sum;
|
329 | }
|
330 | }
|
331 |
|
332 |
|
333 | return a.createDenseMatrix({
|
334 | data: c,
|
335 | size: [arows, bcolumns],
|
336 | datatype: dt
|
337 | });
|
338 | }
|
339 | |
340 |
|
341 |
|
342 |
|
343 |
|
344 |
|
345 |
|
346 |
|
347 |
|
348 |
|
349 | function _multiplyDenseMatrixSparseMatrix(a, b) {
|
350 |
|
351 | var adata = a._data;
|
352 | var asize = a._size;
|
353 | var adt = a._datatype;
|
354 |
|
355 | var bvalues = b._values;
|
356 | var bindex = b._index;
|
357 | var bptr = b._ptr;
|
358 | var bsize = b._size;
|
359 | var bdt = b._datatype;
|
360 |
|
361 | if (!bvalues) {
|
362 | throw new Error('Cannot multiply Dense Matrix times Pattern only Matrix');
|
363 | }
|
364 |
|
365 |
|
366 | var arows = asize[0];
|
367 | var bcolumns = bsize[1];
|
368 |
|
369 | var dt;
|
370 |
|
371 | var af = addScalar;
|
372 |
|
373 | var mf = multiplyScalar;
|
374 |
|
375 | var eq = equalScalar;
|
376 |
|
377 | var zero = 0;
|
378 |
|
379 | if (adt && bdt && adt === bdt && typeof adt === 'string') {
|
380 |
|
381 | dt = adt;
|
382 |
|
383 | af = typed.find(addScalar, [dt, dt]);
|
384 | mf = typed.find(multiplyScalar, [dt, dt]);
|
385 | eq = typed.find(equalScalar, [dt, dt]);
|
386 |
|
387 | zero = typed.convert(0, dt);
|
388 | }
|
389 |
|
390 |
|
391 | var cvalues = [];
|
392 | var cindex = [];
|
393 | var cptr = [];
|
394 |
|
395 | var c = b.createSparseMatrix({
|
396 | values: cvalues,
|
397 | index: cindex,
|
398 | ptr: cptr,
|
399 | size: [arows, bcolumns],
|
400 | datatype: dt
|
401 | });
|
402 |
|
403 | for (var jb = 0; jb < bcolumns; jb++) {
|
404 |
|
405 | cptr[jb] = cindex.length;
|
406 |
|
407 | var kb0 = bptr[jb];
|
408 | var kb1 = bptr[jb + 1];
|
409 |
|
410 | if (kb1 > kb0) {
|
411 |
|
412 | var last = 0;
|
413 |
|
414 | for (var i = 0; i < arows; i++) {
|
415 |
|
416 | var mark = i + 1;
|
417 |
|
418 | var cij = void 0;
|
419 |
|
420 | for (var kb = kb0; kb < kb1; kb++) {
|
421 |
|
422 | var ib = bindex[kb];
|
423 |
|
424 | if (last !== mark) {
|
425 |
|
426 | cij = mf(adata[i][ib], bvalues[kb]);
|
427 |
|
428 | last = mark;
|
429 | } else {
|
430 |
|
431 | cij = af(cij, mf(adata[i][ib], bvalues[kb]));
|
432 | }
|
433 | }
|
434 |
|
435 |
|
436 | if (last === mark && !eq(cij, zero)) {
|
437 |
|
438 | cindex.push(i);
|
439 | cvalues.push(cij);
|
440 | }
|
441 | }
|
442 | }
|
443 | }
|
444 |
|
445 |
|
446 | cptr[bcolumns] = cindex.length;
|
447 |
|
448 | return c;
|
449 | }
|
450 | |
451 |
|
452 |
|
453 |
|
454 |
|
455 |
|
456 |
|
457 |
|
458 |
|
459 |
|
460 | function _multiplySparseMatrixVector(a, b) {
|
461 |
|
462 | var avalues = a._values;
|
463 | var aindex = a._index;
|
464 | var aptr = a._ptr;
|
465 | var adt = a._datatype;
|
466 |
|
467 | if (!avalues) {
|
468 | throw new Error('Cannot multiply Pattern only Matrix times Dense Matrix');
|
469 | }
|
470 |
|
471 |
|
472 | var bdata = b._data;
|
473 | var bdt = b._datatype;
|
474 |
|
475 | var arows = a._size[0];
|
476 | var brows = b._size[0];
|
477 |
|
478 | var cvalues = [];
|
479 | var cindex = [];
|
480 | var cptr = [];
|
481 |
|
482 | var dt;
|
483 |
|
484 | var af = addScalar;
|
485 |
|
486 | var mf = multiplyScalar;
|
487 |
|
488 | var eq = equalScalar;
|
489 |
|
490 | var zero = 0;
|
491 |
|
492 | if (adt && bdt && adt === bdt && typeof adt === 'string') {
|
493 |
|
494 | dt = adt;
|
495 |
|
496 | af = typed.find(addScalar, [dt, dt]);
|
497 | mf = typed.find(multiplyScalar, [dt, dt]);
|
498 | eq = typed.find(equalScalar, [dt, dt]);
|
499 |
|
500 | zero = typed.convert(0, dt);
|
501 | }
|
502 |
|
503 |
|
504 | var x = [];
|
505 |
|
506 | var w = [];
|
507 |
|
508 | cptr[0] = 0;
|
509 |
|
510 | for (var ib = 0; ib < brows; ib++) {
|
511 |
|
512 | var vbi = bdata[ib];
|
513 |
|
514 | if (!eq(vbi, zero)) {
|
515 |
|
516 | for (var ka0 = aptr[ib], ka1 = aptr[ib + 1], ka = ka0; ka < ka1; ka++) {
|
517 |
|
518 | var ia = aindex[ka];
|
519 |
|
520 | if (!w[ia]) {
|
521 |
|
522 | w[ia] = true;
|
523 |
|
524 | cindex.push(ia);
|
525 |
|
526 | x[ia] = mf(vbi, avalues[ka]);
|
527 | } else {
|
528 |
|
529 | x[ia] = af(x[ia], mf(vbi, avalues[ka]));
|
530 | }
|
531 | }
|
532 | }
|
533 | }
|
534 |
|
535 |
|
536 | for (var p1 = cindex.length, p = 0; p < p1; p++) {
|
537 |
|
538 | var ic = cindex[p];
|
539 |
|
540 | cvalues[p] = x[ic];
|
541 | }
|
542 |
|
543 |
|
544 | cptr[1] = cindex.length;
|
545 |
|
546 | return a.createSparseMatrix({
|
547 | values: cvalues,
|
548 | index: cindex,
|
549 | ptr: cptr,
|
550 | size: [arows, 1],
|
551 | datatype: dt
|
552 | });
|
553 | }
|
554 | |
555 |
|
556 |
|
557 |
|
558 |
|
559 |
|
560 |
|
561 |
|
562 |
|
563 |
|
564 | function _multiplySparseMatrixDenseMatrix(a, b) {
|
565 |
|
566 | var avalues = a._values;
|
567 | var aindex = a._index;
|
568 | var aptr = a._ptr;
|
569 | var adt = a._datatype;
|
570 |
|
571 | if (!avalues) {
|
572 | throw new Error('Cannot multiply Pattern only Matrix times Dense Matrix');
|
573 | }
|
574 |
|
575 |
|
576 | var bdata = b._data;
|
577 | var bdt = b._datatype;
|
578 |
|
579 | var arows = a._size[0];
|
580 | var brows = b._size[0];
|
581 | var bcolumns = b._size[1];
|
582 |
|
583 | var dt;
|
584 |
|
585 | var af = addScalar;
|
586 |
|
587 | var mf = multiplyScalar;
|
588 |
|
589 | var eq = equalScalar;
|
590 |
|
591 | var zero = 0;
|
592 |
|
593 | if (adt && bdt && adt === bdt && typeof adt === 'string') {
|
594 |
|
595 | dt = adt;
|
596 |
|
597 | af = typed.find(addScalar, [dt, dt]);
|
598 | mf = typed.find(multiplyScalar, [dt, dt]);
|
599 | eq = typed.find(equalScalar, [dt, dt]);
|
600 |
|
601 | zero = typed.convert(0, dt);
|
602 | }
|
603 |
|
604 |
|
605 | var cvalues = [];
|
606 | var cindex = [];
|
607 | var cptr = [];
|
608 |
|
609 | var c = a.createSparseMatrix({
|
610 | values: cvalues,
|
611 | index: cindex,
|
612 | ptr: cptr,
|
613 | size: [arows, bcolumns],
|
614 | datatype: dt
|
615 | });
|
616 |
|
617 | var x = [];
|
618 |
|
619 | var w = [];
|
620 |
|
621 | for (var jb = 0; jb < bcolumns; jb++) {
|
622 |
|
623 | cptr[jb] = cindex.length;
|
624 |
|
625 | var mark = jb + 1;
|
626 |
|
627 | for (var ib = 0; ib < brows; ib++) {
|
628 |
|
629 | var vbij = bdata[ib][jb];
|
630 |
|
631 | if (!eq(vbij, zero)) {
|
632 |
|
633 | for (var ka0 = aptr[ib], ka1 = aptr[ib + 1], ka = ka0; ka < ka1; ka++) {
|
634 |
|
635 | var ia = aindex[ka];
|
636 |
|
637 | if (w[ia] !== mark) {
|
638 |
|
639 | w[ia] = mark;
|
640 |
|
641 | cindex.push(ia);
|
642 |
|
643 | x[ia] = mf(vbij, avalues[ka]);
|
644 | } else {
|
645 |
|
646 | x[ia] = af(x[ia], mf(vbij, avalues[ka]));
|
647 | }
|
648 | }
|
649 | }
|
650 | }
|
651 |
|
652 |
|
653 | for (var p0 = cptr[jb], p1 = cindex.length, p = p0; p < p1; p++) {
|
654 |
|
655 | var ic = cindex[p];
|
656 |
|
657 | cvalues[p] = x[ic];
|
658 | }
|
659 | }
|
660 |
|
661 |
|
662 | cptr[bcolumns] = cindex.length;
|
663 |
|
664 | return c;
|
665 | }
|
666 | |
667 |
|
668 |
|
669 |
|
670 |
|
671 |
|
672 |
|
673 |
|
674 |
|
675 |
|
676 | function _multiplySparseMatrixSparseMatrix(a, b) {
|
677 |
|
678 | var avalues = a._values;
|
679 | var aindex = a._index;
|
680 | var aptr = a._ptr;
|
681 | var adt = a._datatype;
|
682 |
|
683 | var bvalues = b._values;
|
684 | var bindex = b._index;
|
685 | var bptr = b._ptr;
|
686 | var bdt = b._datatype;
|
687 |
|
688 | var arows = a._size[0];
|
689 | var bcolumns = b._size[1];
|
690 |
|
691 | var values = avalues && bvalues;
|
692 |
|
693 | var dt;
|
694 |
|
695 | var af = addScalar;
|
696 |
|
697 | var mf = multiplyScalar;
|
698 |
|
699 | if (adt && bdt && adt === bdt && typeof adt === 'string') {
|
700 |
|
701 | dt = adt;
|
702 |
|
703 | af = typed.find(addScalar, [dt, dt]);
|
704 | mf = typed.find(multiplyScalar, [dt, dt]);
|
705 | }
|
706 |
|
707 |
|
708 | var cvalues = values ? [] : undefined;
|
709 | var cindex = [];
|
710 | var cptr = [];
|
711 |
|
712 | var c = a.createSparseMatrix({
|
713 | values: cvalues,
|
714 | index: cindex,
|
715 | ptr: cptr,
|
716 | size: [arows, bcolumns],
|
717 | datatype: dt
|
718 | });
|
719 |
|
720 | var x = values ? [] : undefined;
|
721 |
|
722 | var w = [];
|
723 |
|
724 | var ka, ka0, ka1, kb, kb0, kb1, ia, ib;
|
725 |
|
726 | for (var jb = 0; jb < bcolumns; jb++) {
|
727 |
|
728 | cptr[jb] = cindex.length;
|
729 |
|
730 | var mark = jb + 1;
|
731 |
|
732 | for (kb0 = bptr[jb], kb1 = bptr[jb + 1], kb = kb0; kb < kb1; kb++) {
|
733 |
|
734 | ib = bindex[kb];
|
735 |
|
736 | if (values) {
|
737 |
|
738 | for (ka0 = aptr[ib], ka1 = aptr[ib + 1], ka = ka0; ka < ka1; ka++) {
|
739 |
|
740 | ia = aindex[ka];
|
741 |
|
742 | if (w[ia] !== mark) {
|
743 |
|
744 | w[ia] = mark;
|
745 |
|
746 | cindex.push(ia);
|
747 |
|
748 | x[ia] = mf(bvalues[kb], avalues[ka]);
|
749 | } else {
|
750 |
|
751 | x[ia] = af(x[ia], mf(bvalues[kb], avalues[ka]));
|
752 | }
|
753 | }
|
754 | } else {
|
755 |
|
756 | for (ka0 = aptr[ib], ka1 = aptr[ib + 1], ka = ka0; ka < ka1; ka++) {
|
757 |
|
758 | ia = aindex[ka];
|
759 |
|
760 | if (w[ia] !== mark) {
|
761 |
|
762 | w[ia] = mark;
|
763 |
|
764 | cindex.push(ia);
|
765 | }
|
766 | }
|
767 | }
|
768 | }
|
769 |
|
770 |
|
771 | if (values) {
|
772 |
|
773 | for (var p0 = cptr[jb], p1 = cindex.length, p = p0; p < p1; p++) {
|
774 |
|
775 | var ic = cindex[p];
|
776 |
|
777 | cvalues[p] = x[ic];
|
778 | }
|
779 | }
|
780 | }
|
781 |
|
782 |
|
783 | cptr[bcolumns] = cindex.length;
|
784 |
|
785 | return c;
|
786 | }
|
787 | |
788 |
|
789 |
|
790 |
|
791 |
|
792 |
|
793 |
|
794 |
|
795 |
|
796 |
|
797 |
|
798 |
|
799 |
|
800 |
|
801 |
|
802 |
|
803 |
|
804 |
|
805 |
|
806 |
|
807 |
|
808 |
|
809 |
|
810 |
|
811 |
|
812 |
|
813 |
|
814 |
|
815 |
|
816 |
|
817 |
|
818 |
|
819 |
|
820 |
|
821 |
|
822 | return typed(name, extend({
|
823 |
|
824 | 'Array, Array': function ArrayArray(x, y) {
|
825 |
|
826 | _validateMatrixDimensions(arraySize(x), arraySize(y));
|
827 |
|
828 |
|
829 | var m = this(matrix(x), matrix(y));
|
830 |
|
831 | return isMatrix(m) ? m.valueOf() : m;
|
832 | },
|
833 | 'Matrix, Matrix': function MatrixMatrix(x, y) {
|
834 |
|
835 | var xsize = x.size();
|
836 | var ysize = y.size();
|
837 |
|
838 | _validateMatrixDimensions(xsize, ysize);
|
839 |
|
840 |
|
841 | if (xsize.length === 1) {
|
842 |
|
843 | if (ysize.length === 1) {
|
844 |
|
845 | return _multiplyVectorVector(x, y, xsize[0]);
|
846 | }
|
847 |
|
848 |
|
849 | return _multiplyVectorMatrix(x, y);
|
850 | }
|
851 |
|
852 |
|
853 | if (ysize.length === 1) {
|
854 |
|
855 | return _multiplyMatrixVector(x, y);
|
856 | }
|
857 |
|
858 |
|
859 | return _multiplyMatrixMatrix(x, y);
|
860 | },
|
861 | 'Matrix, Array': function MatrixArray(x, y) {
|
862 |
|
863 | return this(x, matrix(y));
|
864 | },
|
865 | 'Array, Matrix': function ArrayMatrix(x, y) {
|
866 |
|
867 | return this(matrix(x, y.storage()), y);
|
868 | },
|
869 | 'SparseMatrix, any': function SparseMatrixAny(x, y) {
|
870 | return algorithm11(x, y, multiplyScalar, false);
|
871 | },
|
872 | 'DenseMatrix, any': function DenseMatrixAny(x, y) {
|
873 | return algorithm14(x, y, multiplyScalar, false);
|
874 | },
|
875 | 'any, SparseMatrix': function anySparseMatrix(x, y) {
|
876 | return algorithm11(y, x, multiplyScalar, true);
|
877 | },
|
878 | 'any, DenseMatrix': function anyDenseMatrix(x, y) {
|
879 | return algorithm14(y, x, multiplyScalar, true);
|
880 | },
|
881 | 'Array, any': function ArrayAny(x, y) {
|
882 |
|
883 | return algorithm14(matrix(x), y, multiplyScalar, false).valueOf();
|
884 | },
|
885 | 'any, Array': function anyArray(x, y) {
|
886 |
|
887 | return algorithm14(matrix(y), x, multiplyScalar, true).valueOf();
|
888 | },
|
889 | 'any, any': multiplyScalar,
|
890 | 'any, any, ...any': function anyAnyAny(x, y, rest) {
|
891 | var result = this(x, y);
|
892 |
|
893 | for (var i = 0; i < rest.length; i++) {
|
894 | result = this(result, rest[i]);
|
895 | }
|
896 |
|
897 | return result;
|
898 | }
|
899 | }, multiplyScalar.signatures));
|
900 | }); |
\ | No newline at end of file |