1 | "use strict";
|
2 |
|
3 | Object.defineProperty(exports, "__esModule", {
|
4 | value: true
|
5 | });
|
6 | exports.createDenseMatrixClass = void 0;
|
7 |
|
8 | var _is = require("../../utils/is");
|
9 |
|
10 | var _array = require("../../utils/array");
|
11 |
|
12 | var _string = require("../../utils/string");
|
13 |
|
14 | var _number = require("../../utils/number");
|
15 |
|
16 | var _object = require("../../utils/object");
|
17 |
|
18 | var _DimensionError = require("../../error/DimensionError");
|
19 |
|
20 | var _factory = require("../../utils/factory");
|
21 |
|
22 | var name = 'DenseMatrix';
|
23 | var dependencies = ['Matrix'];
|
24 | var createDenseMatrixClass =
|
25 |
|
26 | (0, _factory.factory)(name, dependencies, function (_ref) {
|
27 | var Matrix = _ref.Matrix;
|
28 |
|
29 | |
30 |
|
31 |
|
32 |
|
33 | function DenseMatrix(data, datatype) {
|
34 | if (!(this instanceof DenseMatrix)) {
|
35 | throw new SyntaxError('Constructor must be called with the new operator');
|
36 | }
|
37 |
|
38 | if (datatype && !(0, _is.isString)(datatype)) {
|
39 | throw new Error('Invalid datatype: ' + datatype);
|
40 | }
|
41 |
|
42 | if ((0, _is.isMatrix)(data)) {
|
43 |
|
44 | if (data.type === 'DenseMatrix') {
|
45 |
|
46 | this._data = (0, _object.clone)(data._data);
|
47 | this._size = (0, _object.clone)(data._size);
|
48 | this._datatype = datatype || data._datatype;
|
49 | } else {
|
50 |
|
51 | this._data = data.toArray();
|
52 | this._size = data.size();
|
53 | this._datatype = datatype || data._datatype;
|
54 | }
|
55 | } else if (data && (0, _is.isArray)(data.data) && (0, _is.isArray)(data.size)) {
|
56 |
|
57 | this._data = data.data;
|
58 | this._size = data.size;
|
59 | this._datatype = datatype || data.datatype;
|
60 | } else if ((0, _is.isArray)(data)) {
|
61 |
|
62 | this._data = preprocess(data);
|
63 |
|
64 | this._size = (0, _array.arraySize)(this._data);
|
65 |
|
66 | (0, _array.validate)(this._data, this._size);
|
67 |
|
68 | this._datatype = datatype;
|
69 | } else if (data) {
|
70 |
|
71 | throw new TypeError('Unsupported type of data (' + (0, _is.typeOf)(data) + ')');
|
72 | } else {
|
73 |
|
74 | this._data = [];
|
75 | this._size = [0];
|
76 | this._datatype = datatype;
|
77 | }
|
78 | }
|
79 |
|
80 | DenseMatrix.prototype = new Matrix();
|
81 | |
82 |
|
83 |
|
84 |
|
85 | DenseMatrix.prototype.createDenseMatrix = function (data, datatype) {
|
86 | return new DenseMatrix(data, datatype);
|
87 | };
|
88 | |
89 |
|
90 |
|
91 |
|
92 |
|
93 | DenseMatrix.prototype.type = 'DenseMatrix';
|
94 | DenseMatrix.prototype.isDenseMatrix = true;
|
95 | |
96 |
|
97 |
|
98 |
|
99 |
|
100 |
|
101 |
|
102 |
|
103 |
|
104 |
|
105 | DenseMatrix.prototype.getDataType = function () {
|
106 | return (0, _array.getArrayDataType)(this._data, _is.typeOf);
|
107 | };
|
108 | |
109 |
|
110 |
|
111 |
|
112 |
|
113 |
|
114 |
|
115 |
|
116 |
|
117 |
|
118 |
|
119 | DenseMatrix.prototype.storage = function () {
|
120 | return 'dense';
|
121 | };
|
122 | |
123 |
|
124 |
|
125 |
|
126 |
|
127 |
|
128 |
|
129 |
|
130 |
|
131 |
|
132 |
|
133 | DenseMatrix.prototype.datatype = function () {
|
134 | return this._datatype;
|
135 | };
|
136 | |
137 |
|
138 |
|
139 |
|
140 |
|
141 |
|
142 |
|
143 |
|
144 | DenseMatrix.prototype.create = function (data, datatype) {
|
145 | return new DenseMatrix(data, datatype);
|
146 | };
|
147 | |
148 |
|
149 |
|
150 |
|
151 |
|
152 |
|
153 |
|
154 |
|
155 |
|
156 |
|
157 |
|
158 |
|
159 |
|
160 |
|
161 |
|
162 |
|
163 | DenseMatrix.prototype.subset = function (index, replacement, defaultValue) {
|
164 | switch (arguments.length) {
|
165 | case 1:
|
166 | return _get(this, index);
|
167 |
|
168 |
|
169 | case 2:
|
170 | case 3:
|
171 | return _set(this, index, replacement, defaultValue);
|
172 |
|
173 | default:
|
174 | throw new SyntaxError('Wrong number of arguments');
|
175 | }
|
176 | };
|
177 | |
178 |
|
179 |
|
180 |
|
181 |
|
182 |
|
183 |
|
184 |
|
185 | DenseMatrix.prototype.get = function (index) {
|
186 | if (!(0, _is.isArray)(index)) {
|
187 | throw new TypeError('Array expected');
|
188 | }
|
189 |
|
190 | if (index.length !== this._size.length) {
|
191 | throw new _DimensionError.DimensionError(index.length, this._size.length);
|
192 | }
|
193 |
|
194 |
|
195 | for (var x = 0; x < index.length; x++) {
|
196 | (0, _array.validateIndex)(index[x], this._size[x]);
|
197 | }
|
198 |
|
199 | var data = this._data;
|
200 |
|
201 | for (var i = 0, ii = index.length; i < ii; i++) {
|
202 | var indexI = index[i];
|
203 | (0, _array.validateIndex)(indexI, data.length);
|
204 | data = data[indexI];
|
205 | }
|
206 |
|
207 | return data;
|
208 | };
|
209 | |
210 |
|
211 |
|
212 |
|
213 |
|
214 |
|
215 |
|
216 |
|
217 |
|
218 |
|
219 |
|
220 |
|
221 | DenseMatrix.prototype.set = function (index, value, defaultValue) {
|
222 | if (!(0, _is.isArray)(index)) {
|
223 | throw new TypeError('Array expected');
|
224 | }
|
225 |
|
226 | if (index.length < this._size.length) {
|
227 | throw new _DimensionError.DimensionError(index.length, this._size.length, '<');
|
228 | }
|
229 |
|
230 | var i, ii, indexI;
|
231 |
|
232 | var size = index.map(function (i) {
|
233 | return i + 1;
|
234 | });
|
235 |
|
236 | _fit(this, size, defaultValue);
|
237 |
|
238 |
|
239 | var data = this._data;
|
240 |
|
241 | for (i = 0, ii = index.length - 1; i < ii; i++) {
|
242 | indexI = index[i];
|
243 | (0, _array.validateIndex)(indexI, data.length);
|
244 | data = data[indexI];
|
245 | }
|
246 |
|
247 |
|
248 | indexI = index[index.length - 1];
|
249 | (0, _array.validateIndex)(indexI, data.length);
|
250 | data[indexI] = value;
|
251 | return this;
|
252 | };
|
253 | |
254 |
|
255 |
|
256 |
|
257 |
|
258 |
|
259 |
|
260 |
|
261 |
|
262 | function _get(matrix, index) {
|
263 | if (!(0, _is.isIndex)(index)) {
|
264 | throw new TypeError('Invalid index');
|
265 | }
|
266 |
|
267 | var isScalar = index.isScalar();
|
268 |
|
269 | if (isScalar) {
|
270 |
|
271 | return matrix.get(index.min());
|
272 | } else {
|
273 |
|
274 | var size = index.size();
|
275 |
|
276 | if (size.length !== matrix._size.length) {
|
277 | throw new _DimensionError.DimensionError(size.length, matrix._size.length);
|
278 | }
|
279 |
|
280 |
|
281 | var min = index.min();
|
282 | var max = index.max();
|
283 |
|
284 | for (var i = 0, ii = matrix._size.length; i < ii; i++) {
|
285 | (0, _array.validateIndex)(min[i], matrix._size[i]);
|
286 | (0, _array.validateIndex)(max[i], matrix._size[i]);
|
287 | }
|
288 |
|
289 |
|
290 |
|
291 | return new DenseMatrix(_getSubmatrix(matrix._data, index, size.length, 0), matrix._datatype);
|
292 | }
|
293 | }
|
294 | |
295 |
|
296 |
|
297 |
|
298 |
|
299 |
|
300 |
|
301 |
|
302 |
|
303 |
|
304 |
|
305 |
|
306 |
|
307 | function _getSubmatrix(data, index, dims, dim) {
|
308 | var last = dim === dims - 1;
|
309 | var range = index.dimension(dim);
|
310 |
|
311 | if (last) {
|
312 | return range.map(function (i) {
|
313 | (0, _array.validateIndex)(i, data.length);
|
314 | return data[i];
|
315 | }).valueOf();
|
316 | } else {
|
317 | return range.map(function (i) {
|
318 | (0, _array.validateIndex)(i, data.length);
|
319 | var child = data[i];
|
320 | return _getSubmatrix(child, index, dims, dim + 1);
|
321 | }).valueOf();
|
322 | }
|
323 | }
|
324 | |
325 |
|
326 |
|
327 |
|
328 |
|
329 |
|
330 |
|
331 |
|
332 |
|
333 |
|
334 |
|
335 |
|
336 |
|
337 |
|
338 | function _set(matrix, index, submatrix, defaultValue) {
|
339 | if (!index || index.isIndex !== true) {
|
340 | throw new TypeError('Invalid index');
|
341 | }
|
342 |
|
343 |
|
344 | var iSize = index.size();
|
345 | var isScalar = index.isScalar();
|
346 |
|
347 | var sSize;
|
348 |
|
349 | if ((0, _is.isMatrix)(submatrix)) {
|
350 | sSize = submatrix.size();
|
351 | submatrix = submatrix.valueOf();
|
352 | } else {
|
353 | sSize = (0, _array.arraySize)(submatrix);
|
354 | }
|
355 |
|
356 | if (isScalar) {
|
357 |
|
358 |
|
359 | if (sSize.length !== 0) {
|
360 | throw new TypeError('Scalar expected');
|
361 | }
|
362 |
|
363 | matrix.set(index.min(), submatrix, defaultValue);
|
364 | } else {
|
365 |
|
366 |
|
367 | if (iSize.length < matrix._size.length) {
|
368 | throw new _DimensionError.DimensionError(iSize.length, matrix._size.length, '<');
|
369 | }
|
370 |
|
371 | if (sSize.length < iSize.length) {
|
372 |
|
373 | var i = 0;
|
374 | var outer = 0;
|
375 |
|
376 | while (iSize[i] === 1 && sSize[i] === 1) {
|
377 | i++;
|
378 | }
|
379 |
|
380 | while (iSize[i] === 1) {
|
381 | outer++;
|
382 | i++;
|
383 | }
|
384 |
|
385 |
|
386 | submatrix = (0, _array.unsqueeze)(submatrix, iSize.length, outer, sSize);
|
387 | }
|
388 |
|
389 |
|
390 | if (!(0, _object.deepStrictEqual)(iSize, sSize)) {
|
391 | throw new _DimensionError.DimensionError(iSize, sSize, '>');
|
392 | }
|
393 |
|
394 |
|
395 | var size = index.max().map(function (i) {
|
396 | return i + 1;
|
397 | });
|
398 |
|
399 | _fit(matrix, size, defaultValue);
|
400 |
|
401 |
|
402 | var dims = iSize.length;
|
403 | var dim = 0;
|
404 |
|
405 | _setSubmatrix(matrix._data, index, submatrix, dims, dim);
|
406 | }
|
407 |
|
408 | return matrix;
|
409 | }
|
410 | |
411 |
|
412 |
|
413 |
|
414 |
|
415 |
|
416 |
|
417 |
|
418 |
|
419 |
|
420 |
|
421 |
|
422 | function _setSubmatrix(data, index, submatrix, dims, dim) {
|
423 | var last = dim === dims - 1;
|
424 | var range = index.dimension(dim);
|
425 |
|
426 | if (last) {
|
427 | range.forEach(function (dataIndex, subIndex) {
|
428 | (0, _array.validateIndex)(dataIndex);
|
429 | data[dataIndex] = submatrix[subIndex[0]];
|
430 | });
|
431 | } else {
|
432 | range.forEach(function (dataIndex, subIndex) {
|
433 | (0, _array.validateIndex)(dataIndex);
|
434 |
|
435 | _setSubmatrix(data[dataIndex], index, submatrix[subIndex[0]], dims, dim + 1);
|
436 | });
|
437 | }
|
438 | }
|
439 | |
440 |
|
441 |
|
442 |
|
443 |
|
444 |
|
445 |
|
446 |
|
447 |
|
448 |
|
449 |
|
450 |
|
451 |
|
452 |
|
453 |
|
454 | DenseMatrix.prototype.resize = function (size, defaultValue, copy) {
|
455 |
|
456 | if (!(0, _is.isArray)(size)) {
|
457 | throw new TypeError('Array expected');
|
458 | }
|
459 |
|
460 |
|
461 | var m = copy ? this.clone() : this;
|
462 |
|
463 | return _resize(m, size, defaultValue);
|
464 | };
|
465 |
|
466 | function _resize(matrix, size, defaultValue) {
|
467 |
|
468 | if (size.length === 0) {
|
469 |
|
470 | var v = matrix._data;
|
471 |
|
472 | while ((0, _is.isArray)(v)) {
|
473 | v = v[0];
|
474 | }
|
475 |
|
476 | return v;
|
477 | }
|
478 |
|
479 |
|
480 | matrix._size = size.slice(0);
|
481 |
|
482 | matrix._data = (0, _array.resize)(matrix._data, matrix._size, defaultValue);
|
483 |
|
484 | return matrix;
|
485 | }
|
486 | |
487 |
|
488 |
|
489 |
|
490 |
|
491 |
|
492 |
|
493 |
|
494 |
|
495 |
|
496 |
|
497 |
|
498 |
|
499 |
|
500 |
|
501 |
|
502 | DenseMatrix.prototype.reshape = function (size, copy) {
|
503 | var m = copy ? this.clone() : this;
|
504 | m._data = (0, _array.reshape)(m._data, size);
|
505 | m._size = size.slice(0);
|
506 | return m;
|
507 | };
|
508 | |
509 |
|
510 |
|
511 |
|
512 |
|
513 |
|
514 |
|
515 |
|
516 |
|
517 |
|
518 |
|
519 | function _fit(matrix, size, defaultValue) {
|
520 | var
|
521 | newSize = matrix._size.slice(0);
|
522 |
|
523 | var changed = false;
|
524 |
|
525 | while (newSize.length < size.length) {
|
526 | newSize.push(0);
|
527 | changed = true;
|
528 | }
|
529 |
|
530 |
|
531 | for (var i = 0, ii = size.length; i < ii; i++) {
|
532 | if (size[i] > newSize[i]) {
|
533 | newSize[i] = size[i];
|
534 | changed = true;
|
535 | }
|
536 | }
|
537 |
|
538 | if (changed) {
|
539 |
|
540 | _resize(matrix, newSize, defaultValue);
|
541 | }
|
542 | }
|
543 | |
544 |
|
545 |
|
546 |
|
547 |
|
548 |
|
549 |
|
550 | DenseMatrix.prototype.clone = function () {
|
551 | var m = new DenseMatrix({
|
552 | data: (0, _object.clone)(this._data),
|
553 | size: (0, _object.clone)(this._size),
|
554 | datatype: this._datatype
|
555 | });
|
556 | return m;
|
557 | };
|
558 | |
559 |
|
560 |
|
561 |
|
562 |
|
563 |
|
564 |
|
565 | DenseMatrix.prototype.size = function () {
|
566 | return this._size.slice(0);
|
567 | };
|
568 | |
569 |
|
570 |
|
571 |
|
572 |
|
573 |
|
574 |
|
575 |
|
576 |
|
577 |
|
578 |
|
579 |
|
580 | DenseMatrix.prototype.map = function (callback) {
|
581 |
|
582 | var me = this;
|
583 |
|
584 | var recurse = function recurse(value, index) {
|
585 | if ((0, _is.isArray)(value)) {
|
586 | return value.map(function (child, i) {
|
587 | return recurse(child, index.concat(i));
|
588 | });
|
589 | } else {
|
590 | return callback(value, index, me);
|
591 | }
|
592 | };
|
593 |
|
594 |
|
595 | return new DenseMatrix({
|
596 | data: recurse(this._data, []),
|
597 | size: (0, _object.clone)(this._size),
|
598 | datatype: this._datatype
|
599 | });
|
600 | };
|
601 | |
602 |
|
603 |
|
604 |
|
605 |
|
606 |
|
607 |
|
608 |
|
609 |
|
610 | DenseMatrix.prototype.forEach = function (callback) {
|
611 |
|
612 | var me = this;
|
613 |
|
614 | var recurse = function recurse(value, index) {
|
615 | if ((0, _is.isArray)(value)) {
|
616 | value.forEach(function (child, i) {
|
617 | recurse(child, index.concat(i));
|
618 | });
|
619 | } else {
|
620 | callback(value, index, me);
|
621 | }
|
622 | };
|
623 |
|
624 | recurse(this._data, []);
|
625 | };
|
626 | |
627 |
|
628 |
|
629 |
|
630 |
|
631 |
|
632 |
|
633 | DenseMatrix.prototype.toArray = function () {
|
634 | return (0, _object.clone)(this._data);
|
635 | };
|
636 | |
637 |
|
638 |
|
639 |
|
640 |
|
641 |
|
642 |
|
643 | DenseMatrix.prototype.valueOf = function () {
|
644 | return this._data;
|
645 | };
|
646 | |
647 |
|
648 |
|
649 |
|
650 |
|
651 |
|
652 |
|
653 |
|
654 |
|
655 |
|
656 |
|
657 | DenseMatrix.prototype.format = function (options) {
|
658 | return (0, _string.format)(this._data, options);
|
659 | };
|
660 | |
661 |
|
662 |
|
663 |
|
664 |
|
665 |
|
666 |
|
667 | DenseMatrix.prototype.toString = function () {
|
668 | return (0, _string.format)(this._data);
|
669 | };
|
670 | |
671 |
|
672 |
|
673 |
|
674 |
|
675 |
|
676 |
|
677 | DenseMatrix.prototype.toJSON = function () {
|
678 | return {
|
679 | mathjs: 'DenseMatrix',
|
680 | data: this._data,
|
681 | size: this._size,
|
682 | datatype: this._datatype
|
683 | };
|
684 | };
|
685 | |
686 |
|
687 |
|
688 |
|
689 |
|
690 |
|
691 |
|
692 |
|
693 |
|
694 |
|
695 | DenseMatrix.prototype.diagonal = function (k) {
|
696 |
|
697 | if (k) {
|
698 |
|
699 | if ((0, _is.isBigNumber)(k)) {
|
700 | k = k.toNumber();
|
701 | }
|
702 |
|
703 |
|
704 | if (!(0, _is.isNumber)(k) || !(0, _number.isInteger)(k)) {
|
705 | throw new TypeError('The parameter k must be an integer number');
|
706 | }
|
707 | } else {
|
708 |
|
709 | k = 0;
|
710 | }
|
711 |
|
712 | var kSuper = k > 0 ? k : 0;
|
713 | var kSub = k < 0 ? -k : 0;
|
714 |
|
715 | var rows = this._size[0];
|
716 | var columns = this._size[1];
|
717 |
|
718 | var n = Math.min(rows - kSub, columns - kSuper);
|
719 |
|
720 | var data = [];
|
721 |
|
722 | for (var i = 0; i < n; i++) {
|
723 | data[i] = this._data[i + kSub][i + kSuper];
|
724 | }
|
725 |
|
726 |
|
727 | return new DenseMatrix({
|
728 | data: data,
|
729 | size: [n],
|
730 | datatype: this._datatype
|
731 | });
|
732 | };
|
733 | |
734 |
|
735 |
|
736 |
|
737 |
|
738 |
|
739 |
|
740 |
|
741 |
|
742 |
|
743 |
|
744 |
|
745 |
|
746 |
|
747 | DenseMatrix.diagonal = function (size, value, k, defaultValue) {
|
748 | if (!(0, _is.isArray)(size)) {
|
749 | throw new TypeError('Array expected, size parameter');
|
750 | }
|
751 |
|
752 | if (size.length !== 2) {
|
753 | throw new Error('Only two dimensions matrix are supported');
|
754 | }
|
755 |
|
756 |
|
757 | size = size.map(function (s) {
|
758 |
|
759 | if ((0, _is.isBigNumber)(s)) {
|
760 |
|
761 | s = s.toNumber();
|
762 | }
|
763 |
|
764 |
|
765 | if (!(0, _is.isNumber)(s) || !(0, _number.isInteger)(s) || s < 1) {
|
766 | throw new Error('Size values must be positive integers');
|
767 | }
|
768 |
|
769 | return s;
|
770 | });
|
771 |
|
772 | if (k) {
|
773 |
|
774 | if ((0, _is.isBigNumber)(k)) {
|
775 | k = k.toNumber();
|
776 | }
|
777 |
|
778 |
|
779 | if (!(0, _is.isNumber)(k) || !(0, _number.isInteger)(k)) {
|
780 | throw new TypeError('The parameter k must be an integer number');
|
781 | }
|
782 | } else {
|
783 |
|
784 | k = 0;
|
785 | }
|
786 |
|
787 | var kSuper = k > 0 ? k : 0;
|
788 | var kSub = k < 0 ? -k : 0;
|
789 |
|
790 | var rows = size[0];
|
791 | var columns = size[1];
|
792 |
|
793 | var n = Math.min(rows - kSub, columns - kSuper);
|
794 |
|
795 | var _value;
|
796 |
|
797 |
|
798 | if ((0, _is.isArray)(value)) {
|
799 |
|
800 | if (value.length !== n) {
|
801 |
|
802 | throw new Error('Invalid value array length');
|
803 | }
|
804 |
|
805 |
|
806 | _value = function _value(i) {
|
807 |
|
808 | return value[i];
|
809 | };
|
810 | } else if ((0, _is.isMatrix)(value)) {
|
811 |
|
812 | var ms = value.size();
|
813 |
|
814 | if (ms.length !== 1 || ms[0] !== n) {
|
815 |
|
816 | throw new Error('Invalid matrix length');
|
817 | }
|
818 |
|
819 |
|
820 | _value = function _value(i) {
|
821 |
|
822 | return value.get([i]);
|
823 | };
|
824 | } else {
|
825 |
|
826 | _value = function _value() {
|
827 |
|
828 | return value;
|
829 | };
|
830 | }
|
831 |
|
832 |
|
833 | if (!defaultValue) {
|
834 |
|
835 | defaultValue = (0, _is.isBigNumber)(_value(0)) ? _value(0).mul(0)
|
836 | : 0;
|
837 | }
|
838 |
|
839 |
|
840 | var data = [];
|
841 |
|
842 | if (size.length > 0) {
|
843 |
|
844 | data = (0, _array.resize)(data, size, defaultValue);
|
845 |
|
846 | for (var d = 0; d < n; d++) {
|
847 | data[d + kSub][d + kSuper] = _value(d);
|
848 | }
|
849 | }
|
850 |
|
851 |
|
852 | return new DenseMatrix({
|
853 | data: data,
|
854 | size: [rows, columns]
|
855 | });
|
856 | };
|
857 | |
858 |
|
859 |
|
860 |
|
861 |
|
862 |
|
863 |
|
864 |
|
865 |
|
866 |
|
867 | DenseMatrix.fromJSON = function (json) {
|
868 | return new DenseMatrix(json);
|
869 | };
|
870 | |
871 |
|
872 |
|
873 |
|
874 |
|
875 |
|
876 |
|
877 |
|
878 |
|
879 |
|
880 |
|
881 | DenseMatrix.prototype.swapRows = function (i, j) {
|
882 |
|
883 | if (!(0, _is.isNumber)(i) || !(0, _number.isInteger)(i) || !(0, _is.isNumber)(j) || !(0, _number.isInteger)(j)) {
|
884 | throw new Error('Row index must be positive integers');
|
885 | }
|
886 |
|
887 |
|
888 | if (this._size.length !== 2) {
|
889 | throw new Error('Only two dimensional matrix is supported');
|
890 | }
|
891 |
|
892 |
|
893 | (0, _array.validateIndex)(i, this._size[0]);
|
894 | (0, _array.validateIndex)(j, this._size[0]);
|
895 |
|
896 | DenseMatrix._swapRows(i, j, this._data);
|
897 |
|
898 |
|
899 | return this;
|
900 | };
|
901 | |
902 |
|
903 |
|
904 |
|
905 |
|
906 |
|
907 |
|
908 |
|
909 |
|
910 | DenseMatrix._swapRows = function (i, j, data) {
|
911 |
|
912 | var vi = data[i];
|
913 | data[i] = data[j];
|
914 | data[j] = vi;
|
915 | };
|
916 | |
917 |
|
918 |
|
919 |
|
920 |
|
921 |
|
922 |
|
923 |
|
924 |
|
925 | function preprocess(data) {
|
926 | for (var i = 0, ii = data.length; i < ii; i++) {
|
927 | var elem = data[i];
|
928 |
|
929 | if ((0, _is.isArray)(elem)) {
|
930 | data[i] = preprocess(elem);
|
931 | } else if (elem && elem.isMatrix === true) {
|
932 | data[i] = preprocess(elem.valueOf());
|
933 | }
|
934 | }
|
935 |
|
936 | return data;
|
937 | }
|
938 |
|
939 | return DenseMatrix;
|
940 | }, {
|
941 | isClass: true
|
942 | });
|
943 | exports.createDenseMatrixClass = createDenseMatrixClass; |
\ | No newline at end of file |