1 | "use strict";
|
2 |
|
3 | Object.defineProperty(exports, "__esModule", {
|
4 | value: true
|
5 | });
|
6 | exports.createSparseMatrixClass = void 0;
|
7 |
|
8 | var _is = require("../../utils/is");
|
9 |
|
10 | var _number = require("../../utils/number");
|
11 |
|
12 | var _string = require("../../utils/string");
|
13 |
|
14 | var _object = require("../../utils/object");
|
15 |
|
16 | var _array = require("../../utils/array");
|
17 |
|
18 | var _factory = require("../../utils/factory");
|
19 |
|
20 | var _DimensionError = require("../../error/DimensionError");
|
21 |
|
22 | var name = 'SparseMatrix';
|
23 | var dependencies = ['typed', 'equalScalar', 'Matrix'];
|
24 | var createSparseMatrixClass =
|
25 |
|
26 | (0, _factory.factory)(name, dependencies, function (_ref) {
|
27 | var typed = _ref.typed,
|
28 | equalScalar = _ref.equalScalar,
|
29 | Matrix = _ref.Matrix;
|
30 |
|
31 | |
32 |
|
33 |
|
34 |
|
35 |
|
36 | function SparseMatrix(data, datatype) {
|
37 | if (!(this instanceof SparseMatrix)) {
|
38 | throw new SyntaxError('Constructor must be called with the new operator');
|
39 | }
|
40 |
|
41 | if (datatype && !(0, _is.isString)(datatype)) {
|
42 | throw new Error('Invalid datatype: ' + datatype);
|
43 | }
|
44 |
|
45 | if ((0, _is.isMatrix)(data)) {
|
46 |
|
47 | _createFromMatrix(this, data, datatype);
|
48 | } else if (data && (0, _is.isArray)(data.index) && (0, _is.isArray)(data.ptr) && (0, _is.isArray)(data.size)) {
|
49 |
|
50 | this._values = data.values;
|
51 | this._index = data.index;
|
52 | this._ptr = data.ptr;
|
53 | this._size = data.size;
|
54 | this._datatype = datatype || data.datatype;
|
55 | } else if ((0, _is.isArray)(data)) {
|
56 |
|
57 | _createFromArray(this, data, datatype);
|
58 | } else if (data) {
|
59 |
|
60 | throw new TypeError('Unsupported type of data (' + (0, _is.typeOf)(data) + ')');
|
61 | } else {
|
62 |
|
63 | this._values = [];
|
64 | this._index = [];
|
65 | this._ptr = [0];
|
66 | this._size = [0, 0];
|
67 | this._datatype = datatype;
|
68 | }
|
69 | }
|
70 |
|
71 | function _createFromMatrix(matrix, source, datatype) {
|
72 |
|
73 | if (source.type === 'SparseMatrix') {
|
74 |
|
75 | matrix._values = source._values ? (0, _object.clone)(source._values) : undefined;
|
76 | matrix._index = (0, _object.clone)(source._index);
|
77 | matrix._ptr = (0, _object.clone)(source._ptr);
|
78 | matrix._size = (0, _object.clone)(source._size);
|
79 | matrix._datatype = datatype || source._datatype;
|
80 | } else {
|
81 |
|
82 | _createFromArray(matrix, source.valueOf(), datatype || source._datatype);
|
83 | }
|
84 | }
|
85 |
|
86 | function _createFromArray(matrix, data, datatype) {
|
87 |
|
88 | matrix._values = [];
|
89 | matrix._index = [];
|
90 | matrix._ptr = [];
|
91 | matrix._datatype = datatype;
|
92 |
|
93 | var rows = data.length;
|
94 | var columns = 0;
|
95 |
|
96 | var eq = equalScalar;
|
97 |
|
98 | var zero = 0;
|
99 |
|
100 | if ((0, _is.isString)(datatype)) {
|
101 |
|
102 | eq = typed.find(equalScalar, [datatype, datatype]) || equalScalar;
|
103 |
|
104 | zero = typed.convert(0, datatype);
|
105 | }
|
106 |
|
107 |
|
108 | if (rows > 0) {
|
109 |
|
110 | var j = 0;
|
111 |
|
112 | do {
|
113 |
|
114 | matrix._ptr.push(matrix._index.length);
|
115 |
|
116 |
|
117 | for (var i = 0; i < rows; i++) {
|
118 |
|
119 | var row = data[i];
|
120 |
|
121 | if ((0, _is.isArray)(row)) {
|
122 |
|
123 | if (j === 0 && columns < row.length) {
|
124 | columns = row.length;
|
125 | }
|
126 |
|
127 |
|
128 | if (j < row.length) {
|
129 |
|
130 | var v = row[j];
|
131 |
|
132 | if (!eq(v, zero)) {
|
133 |
|
134 | matrix._values.push(v);
|
135 |
|
136 |
|
137 | matrix._index.push(i);
|
138 | }
|
139 | }
|
140 | } else {
|
141 |
|
142 | if (j === 0 && columns < 1) {
|
143 | columns = 1;
|
144 | }
|
145 |
|
146 |
|
147 | if (!eq(row, zero)) {
|
148 |
|
149 | matrix._values.push(row);
|
150 |
|
151 |
|
152 | matrix._index.push(i);
|
153 | }
|
154 | }
|
155 | }
|
156 |
|
157 |
|
158 | j++;
|
159 | } while (j < columns);
|
160 | }
|
161 |
|
162 |
|
163 | matrix._ptr.push(matrix._index.length);
|
164 |
|
165 |
|
166 | matrix._size = [rows, columns];
|
167 | }
|
168 |
|
169 | SparseMatrix.prototype = new Matrix();
|
170 | |
171 |
|
172 |
|
173 |
|
174 | SparseMatrix.prototype.createSparseMatrix = function (data, datatype) {
|
175 | return new SparseMatrix(data, datatype);
|
176 | };
|
177 | |
178 |
|
179 |
|
180 |
|
181 |
|
182 | SparseMatrix.prototype.type = 'SparseMatrix';
|
183 | SparseMatrix.prototype.isSparseMatrix = true;
|
184 | |
185 |
|
186 |
|
187 |
|
188 |
|
189 |
|
190 |
|
191 |
|
192 |
|
193 |
|
194 | SparseMatrix.prototype.getDataType = function () {
|
195 | return (0, _array.getArrayDataType)(this._values, _is.typeOf);
|
196 | };
|
197 | |
198 |
|
199 |
|
200 |
|
201 |
|
202 |
|
203 |
|
204 |
|
205 |
|
206 |
|
207 |
|
208 | SparseMatrix.prototype.storage = function () {
|
209 | return 'sparse';
|
210 | };
|
211 | |
212 |
|
213 |
|
214 |
|
215 |
|
216 |
|
217 |
|
218 |
|
219 |
|
220 |
|
221 |
|
222 | SparseMatrix.prototype.datatype = function () {
|
223 | return this._datatype;
|
224 | };
|
225 | |
226 |
|
227 |
|
228 |
|
229 |
|
230 |
|
231 |
|
232 |
|
233 | SparseMatrix.prototype.create = function (data, datatype) {
|
234 | return new SparseMatrix(data, datatype);
|
235 | };
|
236 | |
237 |
|
238 |
|
239 |
|
240 |
|
241 |
|
242 |
|
243 |
|
244 |
|
245 |
|
246 |
|
247 | SparseMatrix.prototype.density = function () {
|
248 |
|
249 | var rows = this._size[0];
|
250 | var columns = this._size[1];
|
251 |
|
252 | return rows !== 0 && columns !== 0 ? this._index.length / (rows * columns) : 0;
|
253 | };
|
254 | |
255 |
|
256 |
|
257 |
|
258 |
|
259 |
|
260 |
|
261 |
|
262 |
|
263 |
|
264 |
|
265 |
|
266 |
|
267 |
|
268 |
|
269 |
|
270 | SparseMatrix.prototype.subset = function (index, replacement, defaultValue) {
|
271 |
|
272 | if (!this._values) {
|
273 | throw new Error('Cannot invoke subset on a Pattern only matrix');
|
274 | }
|
275 |
|
276 |
|
277 | switch (arguments.length) {
|
278 | case 1:
|
279 | return _getsubset(this, index);
|
280 |
|
281 |
|
282 | case 2:
|
283 | case 3:
|
284 | return _setsubset(this, index, replacement, defaultValue);
|
285 |
|
286 | default:
|
287 | throw new SyntaxError('Wrong number of arguments');
|
288 | }
|
289 | };
|
290 |
|
291 | function _getsubset(matrix, idx) {
|
292 |
|
293 | if (!(0, _is.isIndex)(idx)) {
|
294 | throw new TypeError('Invalid index');
|
295 | }
|
296 |
|
297 | var isScalar = idx.isScalar();
|
298 |
|
299 | if (isScalar) {
|
300 |
|
301 | return matrix.get(idx.min());
|
302 | }
|
303 |
|
304 |
|
305 | var size = idx.size();
|
306 |
|
307 | if (size.length !== matrix._size.length) {
|
308 | throw new _DimensionError.DimensionError(size.length, matrix._size.length);
|
309 | }
|
310 |
|
311 |
|
312 | var i, ii, k, kk;
|
313 |
|
314 | var min = idx.min();
|
315 | var max = idx.max();
|
316 |
|
317 | for (i = 0, ii = matrix._size.length; i < ii; i++) {
|
318 | (0, _array.validateIndex)(min[i], matrix._size[i]);
|
319 | (0, _array.validateIndex)(max[i], matrix._size[i]);
|
320 | }
|
321 |
|
322 |
|
323 | var mvalues = matrix._values;
|
324 | var mindex = matrix._index;
|
325 | var mptr = matrix._ptr;
|
326 |
|
327 | var rows = idx.dimension(0);
|
328 | var columns = idx.dimension(1);
|
329 |
|
330 | var w = [];
|
331 | var pv = [];
|
332 |
|
333 | rows.forEach(function (i, r) {
|
334 |
|
335 | pv[i] = r[0];
|
336 |
|
337 | w[i] = true;
|
338 | });
|
339 |
|
340 | var values = mvalues ? [] : undefined;
|
341 | var index = [];
|
342 | var ptr = [];
|
343 |
|
344 | columns.forEach(function (j) {
|
345 |
|
346 | ptr.push(index.length);
|
347 |
|
348 | for (k = mptr[j], kk = mptr[j + 1]; k < kk; k++) {
|
349 |
|
350 | i = mindex[k];
|
351 |
|
352 | if (w[i] === true) {
|
353 |
|
354 | index.push(pv[i]);
|
355 |
|
356 | if (values) {
|
357 | values.push(mvalues[k]);
|
358 | }
|
359 | }
|
360 | }
|
361 | });
|
362 |
|
363 | ptr.push(index.length);
|
364 |
|
365 | return new SparseMatrix({
|
366 | values: values,
|
367 | index: index,
|
368 | ptr: ptr,
|
369 | size: size,
|
370 | datatype: matrix._datatype
|
371 | });
|
372 | }
|
373 |
|
374 | function _setsubset(matrix, index, submatrix, defaultValue) {
|
375 |
|
376 | if (!index || index.isIndex !== true) {
|
377 | throw new TypeError('Invalid index');
|
378 | }
|
379 |
|
380 |
|
381 | var iSize = index.size();
|
382 | var isScalar = index.isScalar();
|
383 |
|
384 | var sSize;
|
385 |
|
386 | if ((0, _is.isMatrix)(submatrix)) {
|
387 |
|
388 | sSize = submatrix.size();
|
389 |
|
390 | submatrix = submatrix.toArray();
|
391 | } else {
|
392 |
|
393 | sSize = (0, _array.arraySize)(submatrix);
|
394 | }
|
395 |
|
396 |
|
397 | if (isScalar) {
|
398 |
|
399 | if (sSize.length !== 0) {
|
400 | throw new TypeError('Scalar expected');
|
401 | }
|
402 |
|
403 |
|
404 | matrix.set(index.min(), submatrix, defaultValue);
|
405 | } else {
|
406 |
|
407 | if (iSize.length !== 1 && iSize.length !== 2) {
|
408 | throw new _DimensionError.DimensionError(iSize.length, matrix._size.length, '<');
|
409 | }
|
410 |
|
411 |
|
412 | if (sSize.length < iSize.length) {
|
413 |
|
414 | var i = 0;
|
415 | var outer = 0;
|
416 |
|
417 | while (iSize[i] === 1 && sSize[i] === 1) {
|
418 | i++;
|
419 | }
|
420 |
|
421 | while (iSize[i] === 1) {
|
422 | outer++;
|
423 | i++;
|
424 | }
|
425 |
|
426 |
|
427 | submatrix = (0, _array.unsqueeze)(submatrix, iSize.length, outer, sSize);
|
428 | }
|
429 |
|
430 |
|
431 | if (!(0, _object.deepStrictEqual)(iSize, sSize)) {
|
432 | throw new _DimensionError.DimensionError(iSize, sSize, '>');
|
433 | }
|
434 |
|
435 |
|
436 | var x0 = index.min()[0];
|
437 | var y0 = index.min()[1];
|
438 |
|
439 | var m = sSize[0];
|
440 | var n = sSize[1];
|
441 |
|
442 | for (var x = 0; x < m; x++) {
|
443 |
|
444 | for (var y = 0; y < n; y++) {
|
445 |
|
446 | var v = submatrix[x][y];
|
447 |
|
448 | matrix.set([x + x0, y + y0], v, defaultValue);
|
449 | }
|
450 | }
|
451 | }
|
452 |
|
453 | return matrix;
|
454 | }
|
455 | |
456 |
|
457 |
|
458 |
|
459 |
|
460 |
|
461 |
|
462 |
|
463 | SparseMatrix.prototype.get = function (index) {
|
464 | if (!(0, _is.isArray)(index)) {
|
465 | throw new TypeError('Array expected');
|
466 | }
|
467 |
|
468 | if (index.length !== this._size.length) {
|
469 | throw new _DimensionError.DimensionError(index.length, this._size.length);
|
470 | }
|
471 |
|
472 |
|
473 | if (!this._values) {
|
474 | throw new Error('Cannot invoke get on a Pattern only matrix');
|
475 | }
|
476 |
|
477 |
|
478 | var i = index[0];
|
479 | var j = index[1];
|
480 |
|
481 | (0, _array.validateIndex)(i, this._size[0]);
|
482 | (0, _array.validateIndex)(j, this._size[1]);
|
483 |
|
484 | var k = _getValueIndex(i, this._ptr[j], this._ptr[j + 1], this._index);
|
485 |
|
486 |
|
487 | if (k < this._ptr[j + 1] && this._index[k] === i) {
|
488 | return this._values[k];
|
489 | }
|
490 |
|
491 | return 0;
|
492 | };
|
493 | |
494 |
|
495 |
|
496 |
|
497 |
|
498 |
|
499 |
|
500 |
|
501 |
|
502 |
|
503 |
|
504 |
|
505 | SparseMatrix.prototype.set = function (index, v, defaultValue) {
|
506 | if (!(0, _is.isArray)(index)) {
|
507 | throw new TypeError('Array expected');
|
508 | }
|
509 |
|
510 | if (index.length !== this._size.length) {
|
511 | throw new _DimensionError.DimensionError(index.length, this._size.length);
|
512 | }
|
513 |
|
514 |
|
515 | if (!this._values) {
|
516 | throw new Error('Cannot invoke set on a Pattern only matrix');
|
517 | }
|
518 |
|
519 |
|
520 | var i = index[0];
|
521 | var j = index[1];
|
522 |
|
523 | var rows = this._size[0];
|
524 | var columns = this._size[1];
|
525 |
|
526 | var eq = equalScalar;
|
527 |
|
528 | var zero = 0;
|
529 |
|
530 | if ((0, _is.isString)(this._datatype)) {
|
531 |
|
532 | eq = typed.find(equalScalar, [this._datatype, this._datatype]) || equalScalar;
|
533 |
|
534 | zero = typed.convert(0, this._datatype);
|
535 | }
|
536 |
|
537 |
|
538 | if (i > rows - 1 || j > columns - 1) {
|
539 |
|
540 | _resize(this, Math.max(i + 1, rows), Math.max(j + 1, columns), defaultValue);
|
541 |
|
542 |
|
543 | rows = this._size[0];
|
544 | columns = this._size[1];
|
545 | }
|
546 |
|
547 |
|
548 | (0, _array.validateIndex)(i, rows);
|
549 | (0, _array.validateIndex)(j, columns);
|
550 |
|
551 | var k = _getValueIndex(i, this._ptr[j], this._ptr[j + 1], this._index);
|
552 |
|
553 |
|
554 | if (k < this._ptr[j + 1] && this._index[k] === i) {
|
555 |
|
556 | if (!eq(v, zero)) {
|
557 |
|
558 | this._values[k] = v;
|
559 | } else {
|
560 |
|
561 | _remove(k, j, this._values, this._index, this._ptr);
|
562 | }
|
563 | } else {
|
564 |
|
565 | _insert(k, i, j, v, this._values, this._index, this._ptr);
|
566 | }
|
567 |
|
568 | return this;
|
569 | };
|
570 |
|
571 | function _getValueIndex(i, top, bottom, index) {
|
572 |
|
573 | if (bottom - top === 0) {
|
574 | return bottom;
|
575 | }
|
576 |
|
577 |
|
578 | for (var r = top; r < bottom; r++) {
|
579 |
|
580 | if (index[r] === i) {
|
581 | return r;
|
582 | }
|
583 | }
|
584 |
|
585 |
|
586 | return top;
|
587 | }
|
588 |
|
589 | function _remove(k, j, values, index, ptr) {
|
590 |
|
591 | values.splice(k, 1);
|
592 | index.splice(k, 1);
|
593 |
|
594 | for (var x = j + 1; x < ptr.length; x++) {
|
595 | ptr[x]--;
|
596 | }
|
597 | }
|
598 |
|
599 | function _insert(k, i, j, v, values, index, ptr) {
|
600 |
|
601 | values.splice(k, 0, v);
|
602 |
|
603 | index.splice(k, 0, i);
|
604 |
|
605 | for (var x = j + 1; x < ptr.length; x++) {
|
606 | ptr[x]++;
|
607 | }
|
608 | }
|
609 | |
610 |
|
611 |
|
612 |
|
613 |
|
614 |
|
615 |
|
616 |
|
617 |
|
618 |
|
619 |
|
620 |
|
621 |
|
622 |
|
623 |
|
624 | SparseMatrix.prototype.resize = function (size, defaultValue, copy) {
|
625 |
|
626 | if (!(0, _is.isArray)(size)) {
|
627 | throw new TypeError('Array expected');
|
628 | }
|
629 |
|
630 | if (size.length !== 2) {
|
631 | throw new Error('Only two dimensions matrix are supported');
|
632 | }
|
633 |
|
634 |
|
635 | size.forEach(function (value) {
|
636 | if (!(0, _is.isNumber)(value) || !(0, _number.isInteger)(value) || value < 0) {
|
637 | throw new TypeError('Invalid size, must contain positive integers ' + '(size: ' + (0, _string.format)(size) + ')');
|
638 | }
|
639 | });
|
640 |
|
641 | var m = copy ? this.clone() : this;
|
642 |
|
643 | return _resize(m, size[0], size[1], defaultValue);
|
644 | };
|
645 |
|
646 | function _resize(matrix, rows, columns, defaultValue) {
|
647 |
|
648 | var value = defaultValue || 0;
|
649 |
|
650 | var eq = equalScalar;
|
651 |
|
652 | var zero = 0;
|
653 |
|
654 | if ((0, _is.isString)(matrix._datatype)) {
|
655 |
|
656 | eq = typed.find(equalScalar, [matrix._datatype, matrix._datatype]) || equalScalar;
|
657 |
|
658 | zero = typed.convert(0, matrix._datatype);
|
659 |
|
660 | value = typed.convert(value, matrix._datatype);
|
661 | }
|
662 |
|
663 |
|
664 | var ins = !eq(value, zero);
|
665 |
|
666 | var r = matrix._size[0];
|
667 | var c = matrix._size[1];
|
668 | var i, j, k;
|
669 |
|
670 | if (columns > c) {
|
671 |
|
672 | for (j = c; j < columns; j++) {
|
673 |
|
674 | matrix._ptr[j] = matrix._values.length;
|
675 |
|
676 | if (ins) {
|
677 |
|
678 | for (i = 0; i < r; i++) {
|
679 |
|
680 | matrix._values.push(value);
|
681 |
|
682 |
|
683 | matrix._index.push(i);
|
684 | }
|
685 | }
|
686 | }
|
687 |
|
688 |
|
689 | matrix._ptr[columns] = matrix._values.length;
|
690 | } else if (columns < c) {
|
691 |
|
692 | matrix._ptr.splice(columns + 1, c - columns);
|
693 |
|
694 |
|
695 | matrix._values.splice(matrix._ptr[columns], matrix._values.length);
|
696 |
|
697 | matrix._index.splice(matrix._ptr[columns], matrix._index.length);
|
698 | }
|
699 |
|
700 |
|
701 | c = columns;
|
702 |
|
703 | if (rows > r) {
|
704 |
|
705 | if (ins) {
|
706 |
|
707 | var n = 0;
|
708 |
|
709 | for (j = 0; j < c; j++) {
|
710 |
|
711 | matrix._ptr[j] = matrix._ptr[j] + n;
|
712 |
|
713 | k = matrix._ptr[j + 1] + n;
|
714 |
|
715 | var p = 0;
|
716 |
|
717 | for (i = r; i < rows; i++, p++) {
|
718 |
|
719 | matrix._values.splice(k + p, 0, value);
|
720 |
|
721 |
|
722 | matrix._index.splice(k + p, 0, i);
|
723 |
|
724 |
|
725 | n++;
|
726 | }
|
727 | }
|
728 |
|
729 |
|
730 | matrix._ptr[c] = matrix._values.length;
|
731 | }
|
732 | } else if (rows < r) {
|
733 |
|
734 | var d = 0;
|
735 |
|
736 | for (j = 0; j < c; j++) {
|
737 |
|
738 | matrix._ptr[j] = matrix._ptr[j] - d;
|
739 |
|
740 | var k0 = matrix._ptr[j];
|
741 | var k1 = matrix._ptr[j + 1] - d;
|
742 |
|
743 | for (k = k0; k < k1; k++) {
|
744 |
|
745 | i = matrix._index[k];
|
746 |
|
747 | if (i > rows - 1) {
|
748 |
|
749 | matrix._values.splice(k, 1);
|
750 |
|
751 |
|
752 | matrix._index.splice(k, 1);
|
753 |
|
754 |
|
755 | d++;
|
756 | }
|
757 | }
|
758 | }
|
759 |
|
760 |
|
761 | matrix._ptr[j] = matrix._values.length;
|
762 | }
|
763 |
|
764 |
|
765 | matrix._size[0] = rows;
|
766 | matrix._size[1] = columns;
|
767 |
|
768 | return matrix;
|
769 | }
|
770 | |
771 |
|
772 |
|
773 |
|
774 |
|
775 |
|
776 |
|
777 |
|
778 |
|
779 |
|
780 |
|
781 |
|
782 |
|
783 |
|
784 |
|
785 |
|
786 | SparseMatrix.prototype.reshape = function (size, copy) {
|
787 |
|
788 | if (!(0, _is.isArray)(size)) {
|
789 | throw new TypeError('Array expected');
|
790 | }
|
791 |
|
792 | if (size.length !== 2) {
|
793 | throw new Error('Sparse matrices can only be reshaped in two dimensions');
|
794 | }
|
795 |
|
796 |
|
797 | size.forEach(function (value) {
|
798 | if (!(0, _is.isNumber)(value) || !(0, _number.isInteger)(value) || value < 0) {
|
799 | throw new TypeError('Invalid size, must contain positive integers ' + '(size: ' + (0, _string.format)(size) + ')');
|
800 | }
|
801 | });
|
802 |
|
803 | if (this._size[0] * this._size[1] !== size[0] * size[1]) {
|
804 | throw new Error('Reshaping sparse matrix will result in the wrong number of elements');
|
805 | }
|
806 |
|
807 |
|
808 | var m = copy ? this.clone() : this;
|
809 |
|
810 | if (this._size[0] === size[0] && this._size[1] === size[1]) {
|
811 | return m;
|
812 | }
|
813 |
|
814 |
|
815 | var colIndex = [];
|
816 |
|
817 | for (var i = 0; i < m._ptr.length; i++) {
|
818 | for (var j = 0; j < m._ptr[i + 1] - m._ptr[i]; j++) {
|
819 | colIndex.push(i);
|
820 | }
|
821 | }
|
822 |
|
823 |
|
824 | var values = m._values.slice();
|
825 |
|
826 |
|
827 | var rowIndex = m._index.slice();
|
828 |
|
829 |
|
830 | for (var _i = 0; _i < m._index.length; _i++) {
|
831 | var r1 = rowIndex[_i];
|
832 | var c1 = colIndex[_i];
|
833 | var flat = r1 * m._size[1] + c1;
|
834 | colIndex[_i] = flat % size[1];
|
835 | rowIndex[_i] = Math.floor(flat / size[1]);
|
836 | }
|
837 |
|
838 |
|
839 |
|
840 |
|
841 |
|
842 |
|
843 | m._values.length = 0;
|
844 | m._index.length = 0;
|
845 | m._ptr.length = size[1] + 1;
|
846 | m._size = size.slice();
|
847 |
|
848 | for (var _i2 = 0; _i2 < m._ptr.length; _i2++) {
|
849 | m._ptr[_i2] = 0;
|
850 | }
|
851 |
|
852 |
|
853 |
|
854 | for (var h = 0; h < values.length; h++) {
|
855 | var _i3 = rowIndex[h];
|
856 | var _j = colIndex[h];
|
857 | var v = values[h];
|
858 |
|
859 | var k = _getValueIndex(_i3, m._ptr[_j], m._ptr[_j + 1], m._index);
|
860 |
|
861 | _insert(k, _i3, _j, v, m._values, m._index, m._ptr);
|
862 | }
|
863 |
|
864 |
|
865 | return m;
|
866 | };
|
867 | |
868 |
|
869 |
|
870 |
|
871 |
|
872 |
|
873 |
|
874 | SparseMatrix.prototype.clone = function () {
|
875 | var m = new SparseMatrix({
|
876 | values: this._values ? (0, _object.clone)(this._values) : undefined,
|
877 | index: (0, _object.clone)(this._index),
|
878 | ptr: (0, _object.clone)(this._ptr),
|
879 | size: (0, _object.clone)(this._size),
|
880 | datatype: this._datatype
|
881 | });
|
882 | return m;
|
883 | };
|
884 | |
885 |
|
886 |
|
887 |
|
888 |
|
889 |
|
890 |
|
891 | SparseMatrix.prototype.size = function () {
|
892 | return this._size.slice(0);
|
893 | };
|
894 | |
895 |
|
896 |
|
897 |
|
898 |
|
899 |
|
900 |
|
901 |
|
902 |
|
903 |
|
904 |
|
905 |
|
906 |
|
907 | SparseMatrix.prototype.map = function (callback, skipZeros) {
|
908 |
|
909 | if (!this._values) {
|
910 | throw new Error('Cannot invoke map on a Pattern only matrix');
|
911 | }
|
912 |
|
913 |
|
914 | var me = this;
|
915 |
|
916 | var rows = this._size[0];
|
917 | var columns = this._size[1];
|
918 |
|
919 | var invoke = function invoke(v, i, j) {
|
920 |
|
921 | return callback(v, [i, j], me);
|
922 | };
|
923 |
|
924 |
|
925 | return _map(this, 0, rows - 1, 0, columns - 1, invoke, skipZeros);
|
926 | };
|
927 | |
928 |
|
929 |
|
930 |
|
931 |
|
932 |
|
933 | function _map(matrix, minRow, maxRow, minColumn, maxColumn, callback, skipZeros) {
|
934 |
|
935 | var values = [];
|
936 | var index = [];
|
937 | var ptr = [];
|
938 |
|
939 | var eq = equalScalar;
|
940 |
|
941 | var zero = 0;
|
942 |
|
943 | if ((0, _is.isString)(matrix._datatype)) {
|
944 |
|
945 | eq = typed.find(equalScalar, [matrix._datatype, matrix._datatype]) || equalScalar;
|
946 |
|
947 | zero = typed.convert(0, matrix._datatype);
|
948 | }
|
949 |
|
950 |
|
951 | var invoke = function invoke(v, x, y) {
|
952 |
|
953 | v = callback(v, x, y);
|
954 |
|
955 | if (!eq(v, zero)) {
|
956 |
|
957 | values.push(v);
|
958 |
|
959 | index.push(x);
|
960 | }
|
961 | };
|
962 |
|
963 |
|
964 | for (var j = minColumn; j <= maxColumn; j++) {
|
965 |
|
966 | ptr.push(values.length);
|
967 |
|
968 | var k0 = matrix._ptr[j];
|
969 | var k1 = matrix._ptr[j + 1];
|
970 |
|
971 | if (skipZeros) {
|
972 |
|
973 | for (var k = k0; k < k1; k++) {
|
974 |
|
975 | var i = matrix._index[k];
|
976 |
|
977 | if (i >= minRow && i <= maxRow) {
|
978 |
|
979 | invoke(matrix._values[k], i - minRow, j - minColumn);
|
980 | }
|
981 | }
|
982 | } else {
|
983 |
|
984 | var _values = {};
|
985 |
|
986 | for (var _k = k0; _k < k1; _k++) {
|
987 | var _i4 = matrix._index[_k];
|
988 | _values[_i4] = matrix._values[_k];
|
989 | }
|
990 |
|
991 |
|
992 |
|
993 | for (var _i5 = minRow; _i5 <= maxRow; _i5++) {
|
994 | var value = _i5 in _values ? _values[_i5] : 0;
|
995 | invoke(value, _i5 - minRow, j - minColumn);
|
996 | }
|
997 | }
|
998 | }
|
999 |
|
1000 |
|
1001 | ptr.push(values.length);
|
1002 |
|
1003 | return new SparseMatrix({
|
1004 | values: values,
|
1005 | index: index,
|
1006 | ptr: ptr,
|
1007 | size: [maxRow - minRow + 1, maxColumn - minColumn + 1]
|
1008 | });
|
1009 | }
|
1010 | |
1011 |
|
1012 |
|
1013 |
|
1014 |
|
1015 |
|
1016 |
|
1017 |
|
1018 |
|
1019 |
|
1020 | SparseMatrix.prototype.forEach = function (callback, skipZeros) {
|
1021 |
|
1022 | if (!this._values) {
|
1023 | throw new Error('Cannot invoke forEach on a Pattern only matrix');
|
1024 | }
|
1025 |
|
1026 |
|
1027 | var me = this;
|
1028 |
|
1029 | var rows = this._size[0];
|
1030 | var columns = this._size[1];
|
1031 |
|
1032 | for (var j = 0; j < columns; j++) {
|
1033 |
|
1034 | var k0 = this._ptr[j];
|
1035 | var k1 = this._ptr[j + 1];
|
1036 |
|
1037 | if (skipZeros) {
|
1038 |
|
1039 | for (var k = k0; k < k1; k++) {
|
1040 |
|
1041 | var i = this._index[k];
|
1042 |
|
1043 | callback(this._values[k], [i, j], me);
|
1044 | }
|
1045 | } else {
|
1046 |
|
1047 | var values = {};
|
1048 |
|
1049 | for (var _k2 = k0; _k2 < k1; _k2++) {
|
1050 | var _i6 = this._index[_k2];
|
1051 | values[_i6] = this._values[_k2];
|
1052 | }
|
1053 |
|
1054 |
|
1055 |
|
1056 | for (var _i7 = 0; _i7 < rows; _i7++) {
|
1057 | var value = _i7 in values ? values[_i7] : 0;
|
1058 | callback(value, [_i7, j], me);
|
1059 | }
|
1060 | }
|
1061 | }
|
1062 | };
|
1063 | |
1064 |
|
1065 |
|
1066 |
|
1067 |
|
1068 |
|
1069 |
|
1070 | SparseMatrix.prototype.toArray = function () {
|
1071 | return _toArray(this._values, this._index, this._ptr, this._size, true);
|
1072 | };
|
1073 | |
1074 |
|
1075 |
|
1076 |
|
1077 |
|
1078 |
|
1079 |
|
1080 | SparseMatrix.prototype.valueOf = function () {
|
1081 | return _toArray(this._values, this._index, this._ptr, this._size, false);
|
1082 | };
|
1083 |
|
1084 | function _toArray(values, index, ptr, size, copy) {
|
1085 |
|
1086 | var rows = size[0];
|
1087 | var columns = size[1];
|
1088 |
|
1089 | var a = [];
|
1090 |
|
1091 | var i, j;
|
1092 |
|
1093 | for (i = 0; i < rows; i++) {
|
1094 | a[i] = [];
|
1095 |
|
1096 | for (j = 0; j < columns; j++) {
|
1097 | a[i][j] = 0;
|
1098 | }
|
1099 | }
|
1100 |
|
1101 |
|
1102 | for (j = 0; j < columns; j++) {
|
1103 |
|
1104 | var k0 = ptr[j];
|
1105 | var k1 = ptr[j + 1];
|
1106 |
|
1107 | for (var k = k0; k < k1; k++) {
|
1108 |
|
1109 | i = index[k];
|
1110 |
|
1111 | a[i][j] = values ? copy ? (0, _object.clone)(values[k]) : values[k] : 1;
|
1112 | }
|
1113 | }
|
1114 |
|
1115 | return a;
|
1116 | }
|
1117 | |
1118 |
|
1119 |
|
1120 |
|
1121 |
|
1122 |
|
1123 |
|
1124 |
|
1125 |
|
1126 |
|
1127 |
|
1128 | SparseMatrix.prototype.format = function (options) {
|
1129 |
|
1130 | var rows = this._size[0];
|
1131 | var columns = this._size[1];
|
1132 |
|
1133 | var density = this.density();
|
1134 |
|
1135 | var str = 'Sparse Matrix [' + (0, _string.format)(rows, options) + ' x ' + (0, _string.format)(columns, options) + '] density: ' + (0, _string.format)(density, options) + '\n';
|
1136 |
|
1137 | for (var j = 0; j < columns; j++) {
|
1138 |
|
1139 | var k0 = this._ptr[j];
|
1140 | var k1 = this._ptr[j + 1];
|
1141 |
|
1142 | for (var k = k0; k < k1; k++) {
|
1143 |
|
1144 | var i = this._index[k];
|
1145 |
|
1146 | str += '\n (' + (0, _string.format)(i, options) + ', ' + (0, _string.format)(j, options) + ') ==> ' + (this._values ? (0, _string.format)(this._values[k], options) : 'X');
|
1147 | }
|
1148 | }
|
1149 |
|
1150 | return str;
|
1151 | };
|
1152 | |
1153 |
|
1154 |
|
1155 |
|
1156 |
|
1157 |
|
1158 |
|
1159 | SparseMatrix.prototype.toString = function () {
|
1160 | return (0, _string.format)(this.toArray());
|
1161 | };
|
1162 | |
1163 |
|
1164 |
|
1165 |
|
1166 |
|
1167 |
|
1168 |
|
1169 | SparseMatrix.prototype.toJSON = function () {
|
1170 | return {
|
1171 | mathjs: 'SparseMatrix',
|
1172 | values: this._values,
|
1173 | index: this._index,
|
1174 | ptr: this._ptr,
|
1175 | size: this._size,
|
1176 | datatype: this._datatype
|
1177 | };
|
1178 | };
|
1179 | |
1180 |
|
1181 |
|
1182 |
|
1183 |
|
1184 |
|
1185 |
|
1186 |
|
1187 |
|
1188 |
|
1189 | SparseMatrix.prototype.diagonal = function (k) {
|
1190 |
|
1191 | if (k) {
|
1192 |
|
1193 | if ((0, _is.isBigNumber)(k)) {
|
1194 | k = k.toNumber();
|
1195 | }
|
1196 |
|
1197 |
|
1198 | if (!(0, _is.isNumber)(k) || !(0, _number.isInteger)(k)) {
|
1199 | throw new TypeError('The parameter k must be an integer number');
|
1200 | }
|
1201 | } else {
|
1202 |
|
1203 | k = 0;
|
1204 | }
|
1205 |
|
1206 | var kSuper = k > 0 ? k : 0;
|
1207 | var kSub = k < 0 ? -k : 0;
|
1208 |
|
1209 | var rows = this._size[0];
|
1210 | var columns = this._size[1];
|
1211 |
|
1212 | var n = Math.min(rows - kSub, columns - kSuper);
|
1213 |
|
1214 | var values = [];
|
1215 | var index = [];
|
1216 | var ptr = [];
|
1217 |
|
1218 | ptr[0] = 0;
|
1219 |
|
1220 | for (var j = kSuper; j < columns && values.length < n; j++) {
|
1221 |
|
1222 | var k0 = this._ptr[j];
|
1223 | var k1 = this._ptr[j + 1];
|
1224 |
|
1225 | for (var x = k0; x < k1; x++) {
|
1226 |
|
1227 | var i = this._index[x];
|
1228 |
|
1229 | if (i === j - kSuper + kSub) {
|
1230 |
|
1231 | values.push(this._values[x]);
|
1232 |
|
1233 | index[values.length - 1] = i - kSub;
|
1234 |
|
1235 | break;
|
1236 | }
|
1237 | }
|
1238 | }
|
1239 |
|
1240 |
|
1241 | ptr.push(values.length);
|
1242 |
|
1243 | return new SparseMatrix({
|
1244 | values: values,
|
1245 | index: index,
|
1246 | ptr: ptr,
|
1247 | size: [n, 1]
|
1248 | });
|
1249 | };
|
1250 | |
1251 |
|
1252 |
|
1253 |
|
1254 |
|
1255 |
|
1256 |
|
1257 |
|
1258 |
|
1259 |
|
1260 | SparseMatrix.fromJSON = function (json) {
|
1261 | return new SparseMatrix(json);
|
1262 | };
|
1263 | |
1264 |
|
1265 |
|
1266 |
|
1267 |
|
1268 |
|
1269 |
|
1270 |
|
1271 |
|
1272 |
|
1273 |
|
1274 |
|
1275 |
|
1276 |
|
1277 | SparseMatrix.diagonal = function (size, value, k, defaultValue, datatype) {
|
1278 | if (!(0, _is.isArray)(size)) {
|
1279 | throw new TypeError('Array expected, size parameter');
|
1280 | }
|
1281 |
|
1282 | if (size.length !== 2) {
|
1283 | throw new Error('Only two dimensions matrix are supported');
|
1284 | }
|
1285 |
|
1286 |
|
1287 | size = size.map(function (s) {
|
1288 |
|
1289 | if ((0, _is.isBigNumber)(s)) {
|
1290 |
|
1291 | s = s.toNumber();
|
1292 | }
|
1293 |
|
1294 |
|
1295 | if (!(0, _is.isNumber)(s) || !(0, _number.isInteger)(s) || s < 1) {
|
1296 | throw new Error('Size values must be positive integers');
|
1297 | }
|
1298 |
|
1299 | return s;
|
1300 | });
|
1301 |
|
1302 | if (k) {
|
1303 |
|
1304 | if ((0, _is.isBigNumber)(k)) {
|
1305 | k = k.toNumber();
|
1306 | }
|
1307 |
|
1308 |
|
1309 | if (!(0, _is.isNumber)(k) || !(0, _number.isInteger)(k)) {
|
1310 | throw new TypeError('The parameter k must be an integer number');
|
1311 | }
|
1312 | } else {
|
1313 |
|
1314 | k = 0;
|
1315 | }
|
1316 |
|
1317 |
|
1318 | var eq = equalScalar;
|
1319 |
|
1320 | var zero = 0;
|
1321 |
|
1322 | if ((0, _is.isString)(datatype)) {
|
1323 |
|
1324 | eq = typed.find(equalScalar, [datatype, datatype]) || equalScalar;
|
1325 |
|
1326 | zero = typed.convert(0, datatype);
|
1327 | }
|
1328 |
|
1329 | var kSuper = k > 0 ? k : 0;
|
1330 | var kSub = k < 0 ? -k : 0;
|
1331 |
|
1332 | var rows = size[0];
|
1333 | var columns = size[1];
|
1334 |
|
1335 | var n = Math.min(rows - kSub, columns - kSuper);
|
1336 |
|
1337 | var _value;
|
1338 |
|
1339 |
|
1340 | if ((0, _is.isArray)(value)) {
|
1341 |
|
1342 | if (value.length !== n) {
|
1343 |
|
1344 | throw new Error('Invalid value array length');
|
1345 | }
|
1346 |
|
1347 |
|
1348 | _value = function _value(i) {
|
1349 |
|
1350 | return value[i];
|
1351 | };
|
1352 | } else if ((0, _is.isMatrix)(value)) {
|
1353 |
|
1354 | var ms = value.size();
|
1355 |
|
1356 | if (ms.length !== 1 || ms[0] !== n) {
|
1357 |
|
1358 | throw new Error('Invalid matrix length');
|
1359 | }
|
1360 |
|
1361 |
|
1362 | _value = function _value(i) {
|
1363 |
|
1364 | return value.get([i]);
|
1365 | };
|
1366 | } else {
|
1367 |
|
1368 | _value = function _value() {
|
1369 |
|
1370 | return value;
|
1371 | };
|
1372 | }
|
1373 |
|
1374 |
|
1375 | var values = [];
|
1376 | var index = [];
|
1377 | var ptr = [];
|
1378 |
|
1379 | for (var j = 0; j < columns; j++) {
|
1380 |
|
1381 | ptr.push(values.length);
|
1382 |
|
1383 | var i = j - kSuper;
|
1384 |
|
1385 | if (i >= 0 && i < n) {
|
1386 |
|
1387 | var v = _value(i);
|
1388 |
|
1389 |
|
1390 | if (!eq(v, zero)) {
|
1391 |
|
1392 | index.push(i + kSub);
|
1393 |
|
1394 | values.push(v);
|
1395 | }
|
1396 | }
|
1397 | }
|
1398 |
|
1399 |
|
1400 | ptr.push(values.length);
|
1401 |
|
1402 | return new SparseMatrix({
|
1403 | values: values,
|
1404 | index: index,
|
1405 | ptr: ptr,
|
1406 | size: [rows, columns]
|
1407 | });
|
1408 | };
|
1409 | |
1410 |
|
1411 |
|
1412 |
|
1413 |
|
1414 |
|
1415 |
|
1416 |
|
1417 |
|
1418 |
|
1419 |
|
1420 | SparseMatrix.prototype.swapRows = function (i, j) {
|
1421 |
|
1422 | if (!(0, _is.isNumber)(i) || !(0, _number.isInteger)(i) || !(0, _is.isNumber)(j) || !(0, _number.isInteger)(j)) {
|
1423 | throw new Error('Row index must be positive integers');
|
1424 | }
|
1425 |
|
1426 |
|
1427 | if (this._size.length !== 2) {
|
1428 | throw new Error('Only two dimensional matrix is supported');
|
1429 | }
|
1430 |
|
1431 |
|
1432 | (0, _array.validateIndex)(i, this._size[0]);
|
1433 | (0, _array.validateIndex)(j, this._size[0]);
|
1434 |
|
1435 | SparseMatrix._swapRows(i, j, this._size[1], this._values, this._index, this._ptr);
|
1436 |
|
1437 |
|
1438 | return this;
|
1439 | };
|
1440 | |
1441 |
|
1442 |
|
1443 |
|
1444 |
|
1445 |
|
1446 |
|
1447 |
|
1448 |
|
1449 |
|
1450 |
|
1451 | SparseMatrix._forEachRow = function (j, values, index, ptr, callback) {
|
1452 |
|
1453 | var k0 = ptr[j];
|
1454 | var k1 = ptr[j + 1];
|
1455 |
|
1456 | for (var k = k0; k < k1; k++) {
|
1457 |
|
1458 | callback(index[k], values[k]);
|
1459 | }
|
1460 | };
|
1461 | |
1462 |
|
1463 |
|
1464 |
|
1465 |
|
1466 |
|
1467 |
|
1468 |
|
1469 |
|
1470 |
|
1471 |
|
1472 |
|
1473 | SparseMatrix._swapRows = function (x, y, columns, values, index, ptr) {
|
1474 |
|
1475 | for (var j = 0; j < columns; j++) {
|
1476 |
|
1477 | var k0 = ptr[j];
|
1478 | var k1 = ptr[j + 1];
|
1479 |
|
1480 | var kx = _getValueIndex(x, k0, k1, index);
|
1481 |
|
1482 |
|
1483 | var ky = _getValueIndex(y, k0, k1, index);
|
1484 |
|
1485 |
|
1486 | if (kx < k1 && ky < k1 && index[kx] === x && index[ky] === y) {
|
1487 |
|
1488 | if (values) {
|
1489 | var v = values[kx];
|
1490 | values[kx] = values[ky];
|
1491 | values[ky] = v;
|
1492 | }
|
1493 |
|
1494 |
|
1495 | continue;
|
1496 | }
|
1497 |
|
1498 |
|
1499 | if (kx < k1 && index[kx] === x && (ky >= k1 || index[ky] !== y)) {
|
1500 |
|
1501 | var vx = values ? values[kx] : undefined;
|
1502 |
|
1503 | index.splice(ky, 0, y);
|
1504 |
|
1505 | if (values) {
|
1506 | values.splice(ky, 0, vx);
|
1507 | }
|
1508 |
|
1509 |
|
1510 | index.splice(ky <= kx ? kx + 1 : kx, 1);
|
1511 |
|
1512 | if (values) {
|
1513 | values.splice(ky <= kx ? kx + 1 : kx, 1);
|
1514 | }
|
1515 |
|
1516 |
|
1517 | continue;
|
1518 | }
|
1519 |
|
1520 |
|
1521 | if (ky < k1 && index[ky] === y && (kx >= k1 || index[kx] !== x)) {
|
1522 |
|
1523 | var vy = values ? values[ky] : undefined;
|
1524 |
|
1525 | index.splice(kx, 0, x);
|
1526 |
|
1527 | if (values) {
|
1528 | values.splice(kx, 0, vy);
|
1529 | }
|
1530 |
|
1531 |
|
1532 | index.splice(kx <= ky ? ky + 1 : ky, 1);
|
1533 |
|
1534 | if (values) {
|
1535 | values.splice(kx <= ky ? ky + 1 : ky, 1);
|
1536 | }
|
1537 | }
|
1538 | }
|
1539 | };
|
1540 |
|
1541 | return SparseMatrix;
|
1542 | }, {
|
1543 | isClass: true
|
1544 | });
|
1545 | exports.createSparseMatrixClass = createSparseMatrixClass; |
\ | No newline at end of file |