ml-matrix 6.1.2 → 6.4.1

package/History.md

@@ -1,3 +1,39 @@
+## [6.4.1](https://github.com/mljs/matrix/compare/v6.4.0...v6.4.1) (2019-09-30)
+
+
+### Bug Fixes
+
+* correctly ready elements in QR#orthogonalMatrix ([2f527a3](https://github.com/mljs/matrix/commit/2f527a3))
+
+
+
+# [6.4.0](https://github.com/mljs/matrix/compare/v6.3.0...v6.4.0) (2019-08-16)
+
+
+### Features
+
+* add CholeskyDecomposition.isPositiveDefinite method ([#94](https://github.com/mljs/matrix/issues/94)) ([6bb33a9](https://github.com/mljs/matrix/commit/6bb33a9))
+
+
+
+# [6.3.0](https://github.com/mljs/matrix/compare/v6.2.0...v6.3.0) (2019-08-16)
+
+
+### Features
+
+* add UMD build ([#92](https://github.com/mljs/matrix/issues/92)) ([3b82b07](https://github.com/mljs/matrix/commit/3b82b07))
+
+
+
+# [6.2.0](https://github.com/mljs/matrix/compare/v6.1.2...v6.2.0) (2019-07-20)
+
+
+### Features
+
+* add NIPALS loop for factorization ([#91](https://github.com/mljs/matrix/issues/91)) ([043c8b6](https://github.com/mljs/matrix/commit/043c8b6))
+
+
+
 ## [6.1.2](https://github.com/mljs/matrix/compare/v6.1.1...v6.1.2) (2019-06-29)
 
 

package/README.md

@@ -110,7 +110,7 @@ const {
   linearDependencies,
   QrDecomposition,
   LuDecomposition,
-  CholeskyDecomposition
+  CholeskyDecomposition,
 } = require('ml-matrix');
 
 //===========================
@@ -157,7 +157,7 @@ var error = Matrix.sub(b, A.mmul(x)); // The error enables to evaluate the solut
 // QR Decomposition
 
 var A = new Matrix([[2, 3, 5], [4, 1, 6], [1, 3, 0]]);
-var QR = QrDecomposition(A);
+var QR = new QrDecomposition(A);
 var Q = QR.orthogonalMatrix;
 var R = QR.upperTriangularMatrix;
 // So you have the QR decomposition. If you multiply Q by R, you'll see that A = Q.R, with Q orthogonal and R upper triangular
@@ -165,7 +165,7 @@ var R = QR.upperTriangularMatrix;
 // LU Decomposition
 
 var A = new Matrix([[2, 3, 5], [4, 1, 6], [1, 3, 0]]);
-var LU = LuDecomposition(A);
+var LU = new LuDecomposition(A);
 var L = LU.lowerTriangularMatrix;
 var U = LU.upperTriangularMatrix;
 var P = LU.pivotPermutationVector;
@@ -174,13 +174,13 @@ var P = LU.pivotPermutationVector;
 // Cholesky Decomposition
 
 var A = new Matrix([[2, 3, 5], [4, 1, 6], [1, 3, 0]]);
-var cholesky = CholeskyDecomposition(A);
+var cholesky = new CholeskyDecomposition(A);
 var L = cholesky.lowerTriangularMatrix;
 
 // Eigenvalues & eigenvectors
 
 var A = new Matrix([[2, 3, 5], [4, 1, 6], [1, 3, 0]]);
-var e = EigenvalueDecomposition(A);
+var e = new EigenvalueDecomposition(A);
 var real = e.realEigenvalues;
 var imaginary = e.imaginaryEigenvalues;
 var vectors = e.eigenvectorMatrix;
@@ -195,7 +195,7 @@ var A = new Matrix([
   [0, 1, 6, 0],
   [0, 3, 0, 1],
   [0, 0, 1, 0],
-  [0, 1, 2, 0]
+  [0, 1, 2, 0],
 ]);
 var dependencies = linearDependencies(A); // dependencies is a matrix with the dependencies of the rows. When we look row by row, we see that the first row is [0, 0, 0, 0, 0], so it means that the first row is independent, and the second row is [ 0, 0, 0, 4, 1 ], i.e the second row = 4 times the 4th row + the 5th row.
 ```

package/matrix.d.ts

@@ -5,49 +5,51 @@ type MatrixDimension = 'row' | 'column';
 export interface IRandomOptions {
   /**
    * Random number generator.
-   * Default: `Math.random`
+   * @default `Math.random`
    */
   random: () => number;
 }
 export interface IRandomIntOptions {
   /**
    * Minimum value.
-   * Default: 0.
+   * @default `0`
    */
   min: number;
 
   /**
    * Maximum value.
-   * Default: 1000.
+   * @default `1000`
    */
   max: number;
 
   /**
    * Random number generator.
-   * Default: Math.random.
+   * @default `Math.random`
    */
   random: () => number;
 }
 export interface IRepeatOptions {
   /**
    * Number of times the rows should be repeated.
-   * Default: 1.
+   * @default `1`
    */
   rows?: number;
 
   /**
    * Number of times the columns should be repeated.
-   * Default: 1.
+   * @default `1`
    */
   columns?: number;
 }
 export interface IScaleOptions {
   /**
-   * Minimum scaled value. Default: 0.
+   * Minimum scaled value.
+   * @default `0`
    */
   min?: number;
   /**
-   * Maximum scaled value. Default: 1.
+   * Maximum scaled value.
+   * @default `1`
    */
   max?: number;
 }
@@ -76,18 +78,18 @@ export interface IScaleByOptions {
 
 export interface ICovarianceOptions {
   /**
-   * Default: true.
+   * @default `true`
    */
   center?: boolean;
 }
 
 export interface ICorrelationOptions {
   /**
-   * Default: true.
+   * @default `true`
    */
   center?: boolean;
   /**
-   * Default: true.
+   * @default `true`
    */
   scale?: boolean;
 }
@@ -108,17 +110,17 @@ export abstract class AbstractMatrix {
    */
   readonly columns: number;
 
-/**
- * Constructs a matrix with the chosen dimensions from a 1D array.
- * @param newRows - Number of rows.
- * @param newColumns - Number of columns.
- * @param newData - A 1D array containing data for the matrix.
- * @returns The new matrix.
- */
+  /**
+   * Constructs a matrix with the chosen dimensions from a 1D array.
+   * @param newRows - Number of rows.
+   * @param newColumns - Number of columns.
+   * @param newData - A 1D array containing data for the matrix.
+   * @returns The new matrix.
+   */
   static from1DArray(
     newRows: number,
     newColumns: number,
-    newData: number[]
+    newData: number[],
   ): Matrix;
 
   /**
@@ -159,15 +161,11 @@ export abstract class AbstractMatrix {
    * @param options - Options object.
    * @returns The new matrix.
    */
-  static rand(
-    rows: number,
-    columns: number,
-    options?: IRandomOptions
-  ): Matrix;
+  static rand(rows: number, columns: number, options?: IRandomOptions): Matrix;
   static random(
     rows: number,
     columns: number,
-    options?: IRandomOptions
+    options?: IRandomOptions,
   ): Matrix;
 
   /**
@@ -179,14 +177,14 @@ export abstract class AbstractMatrix {
   static randInt(
     rows: number,
     columns: number,
-    options?: IRandomIntOptions
+    options?: IRandomIntOptions,
   ): Matrix;
 
   /**
    * Creates an identity matrix with the given dimension. Values of the diagonal will be 1 and others will be 0.
    * @param rows - Number of rows.
-   * @param columns - Number of columns. Default: rows.
-   * @param value - Value to fill the diagonal with. Default: 1.
+   * @param columns - Number of columns. Default: `rows`.
+   * @param value - Value to fill the diagonal with. Default: `1`.
    * @returns - The new identity matrix.
    */
   static eye(rows: number, columns?: number, value?: number): Matrix;
@@ -217,8 +215,8 @@ export abstract class AbstractMatrix {
 
   /**
    * Returns a matrix whose elements are the maximum between `matrix1` and `matrix2`.
-   * @param matrix1 
-   * @param matrix2 
+   * @param matrix1
+   * @param matrix2
    */
   static max(matrix1: MaybeMatrix, matrix2: MaybeMatrix): Matrix;
 
@@ -318,7 +316,7 @@ export abstract class AbstractMatrix {
   /**
    * Creates a new matrix that is a repetition of the current matrix. New matrix has rows times the number of
    * rows of the original matrix, and columns times the number of columns of the original matrix.
-   * 
+   *
    * @example
    * var matrix = new Matrix([[1, 2]]);
    * matrix.repeat({ rows: 2 }); // [[1, 2], [1, 2]]
@@ -569,7 +567,7 @@ export abstract class AbstractMatrix {
   scaleRows(options?: IScaleOptions): Matrix;
 
   /**
-   * Returns a new column-by-column scaled matrix. 
+   * Returns a new column-by-column scaled matrix.
    * @param options
    * @example
    * var matrix = new Matrix([[1, 2], [-1, 0]]);
@@ -621,31 +619,31 @@ export abstract class AbstractMatrix {
     startRow: number,
     endRow: number,
     startColumn: number,
-    endColumn: number
+    endColumn: number,
   ): Matrix;
 
   /**
    * Returns a subset of the matrix based on an array of row indices.
    * @param indices - Array containing the row indices.
-   * @param startColumn - First column index. Default: 0.
-   * @param endColumn - Last column index. Default: columns - 1.
+   * @param startColumn - First column index. Default: `0`.
+   * @param endColumn - Last column index. Default: `this.columns - 1`.
    */
   subMatrixRow(
     indices: number[],
     startColumn?: number,
-    endColumn?: number
+    endColumn?: number,
   ): Matrix;
 
   /**
    * Returns a subset of the matrix based on an array of column indices.
    * @param indices - Array containing the column indices.
-   * @param startRow - First row index. Default: 0.
-   * @param endRow - Last row index. Default: rows - 1.
+   * @param startRow - First row index. Default: `0`.
+   * @param endRow - Last row index. Default: `this.rows - 1`.
    */
   subMatrixColumn(
     indices: number[],
     startRow?: number,
-    endRow?: number
+    endRow?: number,
   ): Matrix;
 
   /**
@@ -657,7 +655,7 @@ export abstract class AbstractMatrix {
   setSubMatrix(
     matrix: MaybeMatrix | number[],
     startRow: number,
-    startColumn: number
+    startColumn: number,
   ): this;
 
   /**
@@ -737,7 +735,7 @@ export abstract class AbstractMatrix {
    */
   standardDeviation(
     by: MatrixDimension,
-    options?: IVarianceByOptions
+    options?: IVarianceByOptions,
   ): number[];
 
   /**
@@ -806,13 +804,10 @@ export abstract class AbstractMatrix {
   static leftShift(matrix: MaybeMatrix, value: ScalarOrMatrix): Matrix;
   static signPropagatingRightShift(
     matrix: MaybeMatrix,
-    value: ScalarOrMatrix
+    value: ScalarOrMatrix,
   ): Matrix;
   static rightShift(matrix: MaybeMatrix, value: ScalarOrMatrix): Matrix;
-  static zeroFillRightShift(
-    matrix: MaybeMatrix,
-    value: ScalarOrMatrix
-  ): Matrix;
+  static zeroFillRightShift(matrix: MaybeMatrix, value: ScalarOrMatrix): Matrix;
 
   // Functional operators (one arg)
   // inplace
@@ -919,7 +914,7 @@ export class MatrixSelectionView extends AbstractMatrix {
   constructor(
     matrix: AbstractMatrix,
     rowIndices: number[],
-    columnIndices: number[]
+    columnIndices: number[],
   );
 }
 
@@ -929,7 +924,7 @@ export class MatrixSubView extends AbstractMatrix {
     startRow: number,
     endRow: number,
     startColumn: number,
-    endColumn: number
+    endColumn: number,
   );
 }
 
@@ -939,14 +934,14 @@ export class MatrixTransposeView extends AbstractMatrix {
 
 export interface IWrap1DOptions {
   /**
-   * Default: 1.
+   * @default: `1`
    */
   rows?: number;
 }
 
 export function wrap(
   array: number[],
-  options?: IWrap1DOptions
+  options?: IWrap1DOptions,
 ): WrapperMatrix1D;
 
 export function wrap(twoDAray: number[][]): WrapperMatrix2D;
@@ -960,18 +955,20 @@ export class WrapperMatrix2D extends AbstractMatrix {
 }
 
 /**
- * @param useSVD - Default: false.
+ * @param leftHandSide
+ * @param rightHandSide
+ * @param useSVD - Default: `false`.
  */
 export function solve(
   leftHandSide: MaybeMatrix,
   rightHandSide: MaybeMatrix,
-  useSVD?: boolean
+  useSVD?: boolean,
 ): Matrix;
 
 /**
  * Computes the inverse of a matrix.
  * @param matrix - Matrix to invert.
- * @param useSVD - Use the singular value decomposition to compute the inverse. Default: false.
+ * @param useSVD - Use the singular value decomposition to compute the inverse. Default: `false`.
  */
 export function inverse(matrix: MaybeMatrix, useSVD?: boolean): Matrix;
 
@@ -984,13 +981,13 @@ export function determinant(matrix: MaybeMatrix): number;
 export interface ILinearDependenciesOptions {
   /**
    * If an absolute value is inferior to this threshold, it will equals zero.
-   * Default: 10e-10.
+   * @default `10e-10`
    */
   thresholdValue?: number;
 
   /**
    * If the error is inferior to that threshold, the linear combination found is accepted and the row is dependent from other rows.
-   * Default: 10e-10.
+   * @default `10e-10`
    */
   thresholdError?: number;
 }
@@ -1005,55 +1002,52 @@ export interface ILinearDependenciesOptions {
  */
 export function linearDependencies(
   matrix: MaybeMatrix,
-  options?: ILinearDependenciesOptions
+  options?: ILinearDependenciesOptions,
 ): Matrix;
 
 /**
  * Returns inverse of a matrix if it exists or the pseudoinverse.
  * @param matrix
- * @param threshold - Threshold for taking inverse of singular values. Default: Number.EPSILON.
+ * @param threshold - Threshold for taking inverse of singular values. Default: `Number.EPSILON`.
  * @returns - The (pseudo)inverted matrix.
  */
-export function pseudoInverse(
-  matrix: MaybeMatrix,
-  threshold?: number
-): Matrix;
+export function pseudoInverse(matrix: MaybeMatrix, threshold?: number): Matrix;
 
 export function covariance(
   matrix: MaybeMatrix,
-  options?: ICovarianceOptions
+  options?: ICovarianceOptions,
 ): Matrix;
 
 export function covariance(
   xMatrix: MaybeMatrix,
   yMatrix: MaybeMatrix,
-  options?: ICovarianceOptions
+  options?: ICovarianceOptions,
 ): Matrix;
 
 export function correlation(
   matrix: MaybeMatrix,
-  options?: ICorrelationOptions
+  options?: ICorrelationOptions,
 ): Matrix;
 
 export function correlation(
   xMatrix: MaybeMatrix,
   yMatrix: MaybeMatrix,
-  options?: ICorrelationOptions
+  options?: ICorrelationOptions,
 ): Matrix;
 
 export interface ISVDOptions {
   /**
-   * Default: true.
+   * @default `true`
    */
   computeLeftSingularVectors?: boolean;
 
   /**
-   * Default: true.
+   * @default `true`
    */
   computeRightSingularVectors?: boolean;
 
   /**
-   * Default: false.
+   * @default `false`
    */
   autoTranspose?: boolean;
 }
@@ -1096,7 +1090,7 @@ export { SingularValueDecomposition as SVD };
 
 export interface IEVDOptions {
   /**
-   * Default: false.
+   * @default `false`
    */
   assumeSymmetric?: boolean;
 }
@@ -1119,10 +1113,11 @@ export { EigenvalueDecomposition as EVD };
  */
 export class CholeskyDecomposition {
   /**
-   * 
+   *
    * @param value - The matrix to decompose
    */
   constructor(value: MaybeMatrix);
+  isPositiveDefinite(): boolean;
   solve(value: Matrix): Matrix;
   readonly lowerTriangularMatrix: Matrix;
 }
@@ -1165,3 +1160,44 @@ export class QrDecomposition {
 }
 
 export { QrDecomposition as QR };
+
+export interface INipalsOptions {
+  /**
+   * A column vector of length `X.rows` that contains known labels for supervised PLS.
+   */
+  Y?: MaybeMatrix | number[];
+  /**
+   * The maximum number of allowed iterations before beraking the loop if convergence is not achieved.
+   * @default 1000
+   */
+  maxIterations?: boolean;
+  /**
+   * Termination criteria
+   * @default 1e-10
+   */
+  terminationCriteria?: number;
+}
+
+export class Nipals {
+  /**
+   * Implementation of the NIPALS algorithm.
+   * Geladi, P and Kowalski, B.R. (1986)
+   * Partial least squares and regression:
+   * a tutorial.
+   * Analytica Chimica Acta 185, 1-17.
+   * @param X - A matrix to be factored
+   * @param options
+   */
+  constructor(X: MaybeMatrix, options?: INipalsOptions);
+  w: Matrix;
+  s: Matrix;
+  t: number;
+  xResidual: Matrix;
+  p: Matrix;
+  q: Matrix;
+  u: number;
+  yResidual: Matrix;
+  betas: number;
+}
+
+export { Nipals as NIPALS };