refactor: remove configurable super class and circular dependencies

Fixes the library for transpiled browser builds.

BREAKING CHANGE:

* It is no longer possible to make a Matrix class that extends a custom constructor
* `matrix.det()` was moved to a standalone function: `determinant(matrix)`
* `matrix.pseudoInverse()` was moved to a standalone function: `pseudoInverse(matrix)`
* `matrix.linearDependencies()` was moved to a standalone function: `linearDependencies(matrix)`
* Matrix views must be created using their constructors instead of Matrix methods.
  For example, `matrix.transposeView()` becomes `new MatrixTransposeView(matrix)`

Author: targos

matrix.d.ts

@@ -4,66 +4,38 @@ declare module 'ml-matrix' {
   type ScalarOrMatrix = number | Matrix;
   type MatrixDimension = 'row' | 'column';
 
-  class BaseView extends Matrix {}
-  class MatrixColumnView extends BaseView {
-    set(rowIndex: number, columnIndex: number, value: number): MatrixColumnView;
-    get(rowIndex: number): number;
+  export class MatrixColumnView extends Matrix {
+    constructor(matrix: Matrix, column: number);
   }
-  class MatrixColumnSelectionView extends BaseView {
-    set(
-      rowIndex: number,
-      columnIndex: number,
-      value: number
-    ): MatrixColumnSelectionView;
-    get(rowIndex: number, columnIndex: number): number;
+  export class MatrixColumnSelectionView extends Matrix {
+    constructor(matrix: Matrix, columnIndices: number[]);
   }
-  class MatrixFlipColumnView extends BaseView {
-    set(
-      rowIndex: number,
-      columnIndex: number,
-      value: number
-    ): MatrixFlipColumnView;
-    get(rowIndex: number, columnIndex: number): number;
+  export class MatrixFlipColumnView extends Matrix {
+    constructor(matrix: Matrix);
   }
-  class MatrixFlipRowView extends BaseView {
-    set(
-      rowIndex: number,
-      columnIndex: number,
-      value: number
-    ): MatrixFlipRowView;
-    get(rowIndex: number, columnIndex: number): number;
+  export class MatrixFlipRowView extends Matrix {
+    constructor(matrix: Matrix);
   }
-  class MatrixRowView extends BaseView {
-    set(rowIndex: number, columnIndex: number, value: number): MatrixRowView;
-    get(rowIndex: number, columnIndex: number): number;
+  export class MatrixRowView extends Matrix {
+    constructor(matrix: Matrix, row: number);
   }
-  class MatrixRowSelectionView extends BaseView {
-    set(
-      rowIndex: number,
-      columnIndex: number,
-      value: number
-    ): MatrixRowSelectionView;
-    get(rowIndex: number, columnIndex: number): number;
+  export class MatrixRowSelectionView extends Matrix {
+    constructor(matrix: Matrix, rowIndices: number[]);
   }
-  class MatrixSelectionView extends BaseView {
-    set(
-      rowIndex: number,
-      columnIndex: number,
-      value: number
-    ): MatrixSelectionView;
-    get(rowIndex: number, columnIndex: number): number;
+  export class MatrixSelectionView extends Matrix {
+    constructor(matrix: Matrix, rowIndices: number[], columnIndices: number[]);
   }
-  class MatrixSubView extends BaseView {
-    set(rowIndex: number, columnIndex: number, value: number): MatrixSubView;
-    get(rowIndex: number, columnIndex: number): number;
+  export class MatrixSubView extends Matrix {
+    constructor(
+      matrix: Matrix,
+      startRow: number,
+      endRow: number,
+      startColumn: number,
+      endColumn: number
+    );
   }
-  class MatrixTransposeView extends BaseView {
-    set(
-      rowIndex: number,
-      columnIndex: number,
-      value: number
-    ): MatrixTransposeView;
-    get(rowIndex: number, columnIndex: number): number;
+  export class MatrixTransposeView extends BaseView {
+    constructor(matrix: Matrix);
   }
   export class Matrix {
     readonly size: number;
@@ -100,7 +72,7 @@ declare module 'ml-matrix' {
     static checkMatrix(value: any): Matrix;
     static isMatrix(value: any): value is Matrix;
 
-    apply(callback: Function): Matrix;
+    apply(callback: Function): this;
     to1DArray(): number[];
     to2DArray(): number[][];
     isRowVector(): boolean;
@@ -110,7 +82,7 @@ declare module 'ml-matrix' {
     isSymmetric(): boolean;
     isEchelonForm(): boolean;
     isReducedEchelonForm(): boolean;
-    set(rowIndex: number, columnIndex: number, value: number): Matrix;
+    set(rowIndex: number, columnIndex: number, value: number): this;
     get(rowIndex: number, columnIndex: number): number;
     repeat(rowRep: number, colRep: number): Matrix;
     fill(value: number): this;
@@ -224,26 +196,6 @@ declare module 'ml-matrix' {
     ): Matrix;
     selection(rowIndices: number[], columnIndices: number[]): Matrix;
     trace(): number;
-    transposeView(): MatrixTransposeView;
-    rowView(row: number): MatrixRowView;
-    columnView(column: number): MatrixColumnView;
-    flipRowView(): MatrixFlipRowView;
-    flipColumnView(): MatrixFlipColumnView;
-    subMatrixView(
-      startRow: number,
-      endRow: number,
-      startColumn: number,
-      endColumn: number
-    ): MatrixSubView;
-    selectionView(
-      rowIndices: number[],
-      columnIndices: number[]
-    ): MatrixSelectionView;
-    rowSelectionView(rowIndices: number[]): MatrixRowSelectionView;
-    columnSelectionView(columnIndices: number[]): MatrixColumnSelectionView;
-    det(): number;
-    determinant(): number;
-    pseudoInverse(threshold?: number): Matrix;
     clone(): Matrix;
     entropy(eps?: number): number;
     variance(unbiased?: boolean, means?: number[]): number[];
@@ -421,10 +373,17 @@ declare module 'ml-matrix' {
   export { QrDecomposition, QrDecomposition as QR };
 
   export function solve(
-    leftHandSide: Matrix,
-    rightHandSide: Matrix,
+    leftHandSide: MaybeMatrix,
+    rightHandSide: MaybeMatrix,
     useSVD?: boolean
   ): Matrix;
 
-  export function inverse(matrix: Matrix, useSVD?: boolean): Matrix;
+  export function inverse(matrix: MaybeMatrix, useSVD?: boolean): Matrix;
+
+  export function determinant(matrix: MaybeMatrix): number;
+
+  export function pseudoInverse(
+    matrix: MaybeMatrix,
+    threshold?: number
+  ): Matrix;
 }

src/__tests__/matrix/creation.js

@@ -150,7 +150,7 @@ describe('Matrix creation', () => {
 
   it('Symbol.species should work for views', () => {
     var matrix = new Matrix([[1, 1, 1], [1, 1, 1]]);
-    var view = matrix.transposeView();
+    var view = new MatrixTransposeView(matrix);
     expect(matrix.transpose().mmul(matrix)).toStrictEqual(view.mmul(matrix));
   });
 
@@ -168,7 +168,9 @@ describe('Matrix creation', () => {
     expect(JSON.stringify(matrix)).toBe(json);
     const mat1D = wrap(matrix.to1DArray(), { rows: 2 });
     expect(JSON.stringify(mat1D)).toBe(json);
-    const transposeTwice = matrix.transposeView().transposeView();
+    const transposeTwice = new MatrixTransposeView(
+      new MatrixTransposeView(matrix)
+    );
     expect(JSON.stringify(transposeTwice)).toBe(json);
   });
 });

src/__tests__/matrix/utility.js

@@ -1,4 +1,4 @@
-import { Matrix } from '../..';
+import { Matrix, pseudoInverse, determinant } from '../..';
 import * as util from '../../../testUtils';
 
 describe('utility methods', () => {
@@ -87,27 +87,23 @@ describe('utility methods', () => {
   });
 
   it('determinant', () => {
-    var determinant = matrix.det();
-    expect(determinant).toBe(-18);
+    var det = determinant(matrix);
+    expect(det).toBe(-18);
     var subMatrix = matrix.selection([1, 2], [1, 2]);
-    determinant = subMatrix.det();
-    expect(determinant).toBe(-9);
-  });
-
-  it('determinant synonym', () => {
-    expect(matrix.det()).toBe(matrix.determinant());
+    det = determinant(subMatrix);
+    expect(det).toBe(-9);
   });
 
   it('determinant n>3', () => {
     var m = Matrix.rand(5, 5);
-    expect(m.det()).toBeCloseTo(0, -1);
+    expect(determinant(m)).toBeCloseTo(0, -1);
   });
 
   it('determinant wrong size', () => {
     var m1 = Matrix.ones(3, 5);
     var m2 = Matrix.ones(5, 3);
-    expect(() => m1.det()).toThrow(/square/);
-    expect(() => m2.det()).toThrow(/square/);
+    expect(() => determinant(m1)).toThrow(/square/);
+    expect(() => determinant(m2)).toThrow(/square/);
   });
 
   it('norm Frobenius', () => {
@@ -242,23 +238,23 @@ describe('utility methods', () => {
     // Actual values calculated by the Numpy library
 
     var matrix = new Matrix([[2, 4], [7, 1]]);
-    var result = matrix.pseudoInverse().to2DArray();
+    var result = pseudoInverse(matrix).to2DArray();
 
     expect(result[0][0]).toBeCloseTo(-0.03846153846153843, 5);
     expect(result[0][1]).toBeCloseTo(0.15384615384615374, 5);
     expect(result[1][0]).toBeCloseTo(0.2692307692307691, 5);
     expect(result[1][1]).toBeCloseTo(-0.076923076923077, 5);
 
     matrix = new Matrix([[4, 7], [2, 6]]);
-    result = matrix.pseudoInverse().to2DArray();
+    result = pseudoInverse(matrix).to2DArray();
     expect(result[0][0]).toBeCloseTo(0.6, 5);
     expect(result[0][1]).toBeCloseTo(-0.7, 5);
     expect(result[1][0]).toBeCloseTo(-0.2, 5);
     expect(result[1][1]).toBeCloseTo(0.4, 5);
 
     // Example from http://reference.wolfram.com/language/ref/PseudoInverse.html
     matrix = new Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]);
-    result = matrix.pseudoInverse().to2DArray();
+    result = pseudoInverse(matrix).to2DArray();
 
     expect(result[0][0]).toBeCloseTo(-6.38888889e-1, 5);
     expect(result[0][1]).toBeCloseTo(-1.66666667e-1, 5);
@@ -274,7 +270,7 @@ describe('utility methods', () => {
 
     // non-square matrix.
     matrix = new Matrix([[1, 0, 1], [2, 4, 5]]);
-    result = matrix.pseudoInverse().to2DArray();
+    result = pseudoInverse(matrix).to2DArray();
 
     expect(result[0][0]).toBeCloseTo(0.75609756, 5);
     expect(result[0][1]).toBeCloseTo(-0.07317073, 5);

src/__tests__/views/column.js

@@ -1,10 +1,10 @@
-import { Matrix } from '../..';
+import { Matrix, MatrixColumnView } from '../..';
 
 describe('Column view', () => {
   it('should set and get row values', () => {
     const m = Matrix.ones(5, 8);
-    const mcv1 = m.columnView(2);
-    const mcv2 = m.columnView(3);
+    const mcv1 = new MatrixColumnView(m, 2);
+    const mcv2 = new MatrixColumnView(m, 3);
 
     m.set(2, 2, 12);
     m.set(0, 3, 5);

src/__tests__/views/columnSelection.js

@@ -1,9 +1,9 @@
-import { Matrix } from '../..';
+import { Matrix, MatrixColumnSelectionView } from '../..';
 
 describe('Selection column view', () => {
   it('should correctly remap coordinates', () => {
     const m = Matrix.ones(5, 8);
-    const msv = m.columnSelectionView([1, 2]);
+    const msv = new MatrixColumnSelectionView(m, [1, 2]);
 
     expect(m.get(0, 2)).toBe(1);
     msv.set(0, 1, 5);
@@ -12,10 +12,10 @@ describe('Selection column view', () => {
 
   it('should throw when wrong arguments or range', () => {
     const m = Matrix.ones(2, 2);
-    expect(() => m.columnSelectionView([1, 1, 2])).toThrow(
+    expect(() => new MatrixColumnSelectionView(m, [1, 1, 2])).toThrow(
       'column indices are out of range'
     );
-    expect(() => m.columnSelectionView(1)).toThrow(
+    expect(() => new MatrixColumnSelectionView(m, 1)).toThrow(
       'unexpected type for column indices'
     );
   });

src/__tests__/views/flipColumn.js

@@ -1,9 +1,9 @@
-import { Matrix } from '../..';
+import { Matrix, MatrixFlipColumnView } from '../..';
 
 describe('Flip column view', () => {
   it('should set and get values', () => {
     const m = Matrix.ones(5, 8);
-    const view = m.flipColumnView();
+    const view = new MatrixFlipColumnView(m);
 
     m.set(0, 3, 5);
     expect(view.get(0, 4)).toBe(5);

src/__tests__/views/flipRow.js

@@ -1,9 +1,9 @@
-import { Matrix } from '../..';
+import { Matrix, MatrixFlipRowView } from '../..';
 
 describe('Flip row view', () => {
   it('should set and get values', () => {
     const m = Matrix.ones(5, 8);
-    const view = m.flipRowView();
+    const view = new MatrixFlipRowView(m);
 
     m.set(0, 3, 5);
     expect(view.get(4, 3)).toBe(5);

src/__tests__/views/row.js

@@ -1,10 +1,10 @@
-import { Matrix } from '../..';
+import { Matrix, MatrixRowView } from '../..';
 
 describe('Row view', () => {
   it('should set and get column values', () => {
     const m = Matrix.ones(5, 8);
-    const mrv1 = m.rowView(0);
-    const mrv2 = m.rowView(3);
+    const mrv1 = new MatrixRowView(m, 0);
+    const mrv2 = new MatrixRowView(m, 3);
 
     m.set(0, 3, 5);
     m.set(2, 2, 12);

src/__tests__/views/rowSelection.js

@@ -1,9 +1,9 @@
-import { Matrix } from '../..';
+import { Matrix, MatrixRowSelectionView } from '../..';
 
 describe('Selection view', () => {
   it('should correctly remap coordinates', () => {
     const m = Matrix.ones(5, 8);
-    const msv = m.rowSelectionView([1, 2]);
+    const msv = new MatrixRowSelectionView(m, [1, 2]);
 
     expect(m.get(1, 0)).toBe(1);
     msv.set(0, 0, 5);
@@ -12,10 +12,10 @@ describe('Selection view', () => {
 
   it('should throw when wrong arguments or range', () => {
     const m = Matrix.ones(2, 2);
-    expect(() => m.rowSelectionView([1, 1, 2])).toThrow(
+    expect(() => new MatrixRowSelectionView(m, [1, 1, 2])).toThrow(
       'row indices are out of range'
     );
-    expect(() => m.rowSelectionView(1)).toThrow(
+    expect(() => new MatrixRowSelectionView(m, 1)).toThrow(
       'unexpected type for row indices'
     );
   });

src/__tests__/views/selection.js

@@ -1,9 +1,9 @@
-import { Matrix } from '../..';
+import { Matrix, MatrixSelectionView } from '../..';
 
 describe('Selection view', () => {
   it('should correctly remap coordinates', () => {
     const m = Matrix.ones(5, 8);
-    const msv = m.selectionView([1, 2], [2, 1]);
+    const msv = new MatrixSelectionView(m, [1, 2], [2, 1]);
 
     expect(m.get(1, 2)).toBe(1);
     msv.set(0, 0, 5);
@@ -16,7 +16,11 @@ describe('Selection view', () => {
 
   it('should handle typed arrays', () => {
     const m = Matrix.ones(5, 8);
-    const msv = m.selectionView(Int8Array.from([1, 2]), Int8Array.from([2, 1]));
+    const msv = new MatrixSelectionView(
+      m,
+      Int8Array.from([1, 2]),
+      Int8Array.from([2, 1])
+    );
 
     expect(m.get(1, 2)).toBe(1);
     msv.set(0, 0, 5);
@@ -29,7 +33,9 @@ describe('Selection view', () => {
 
   it('should throw when wrong arguments or range', () => {
     const m = Matrix.ones(2, 2);
-    expect(() => m.selectionView([1, 1, 2], [0, 2])).toThrow(RangeError);
-    expect(() => m.selectionView([1, 1])).toThrow(TypeError);
+    expect(() => new MatrixSelectionView(m, [1, 1, 2], [0, 2])).toThrow(
+      RangeError
+    );
+    expect(() => new MatrixSelectionView(m, [1, 1])).toThrow(TypeError);
   });
 });