public static double[] CrossProduct(double[] vector1, double[] vector2) { int length = 3; if (length != vector1.Length || length != vector2.Length) { throw new InvalidOperationException(Properties.Resources.Exception_3DRequired); } double[,] matrix = new double[length, length]; for (int row = 0; row < length; row++) { for (int col = 0; col < length; col++) { if (row == 0) { matrix[row, col] = 1; } else if (row == 1) { matrix[row, col] = vector1[col]; } else if (row == 2) { matrix[row, col] = vector2[col]; } } } return(MatrixFunctions.CrossProduct(matrix)); }
/// <summary> /// Rotates a 2D matrix to a specific angle in a spcific direction (clockwise / counter-clockwise.) /// </summary> public virtual Matrix Rotate(double angle, AngleUnit unit, MatrixRotationDirection direction) { if (Is2DMatrix == false) { throw new InvalidOperationException(Properties.Resources.Exception_2DRequired); } return(new Matrix(MatrixFunctions.Create2DRotationMatrix(angle, unit, direction))); }
/// <summary> /// Rotates a 3D matrix to a specific angle in a given axis. /// </summary> public virtual Matrix Rotate(double angle, AngleUnit unit, MatrixAxis axis) { if (Is3DMatrix == false) { throw new InvalidOperationException(Properties.Resources.Exception_3DRequired); } return(new Matrix(MatrixFunctions.Create3DRotationMatrix(angle, unit, axis))); }
/// <summary> /// Returns true if both matrices contain the same entry values. /// </summary> public bool Equals(double[,] other) { if (other == null) { return(false); } return(MatrixFunctions.Equals(this.InnerMatrix, other)); }
/// <summary> /// Calculates the inverse of matrix. Returns null if non-invertible. /// </summary> public virtual Matrix Invert() { var inverse = MatrixFunctions.Invert(this.InnerMatrix); if (inverse == null) { return(null); } return(new Matrix(inverse)); }
/// <summary> /// Concats another matrix horizontally / vertically. /// </summary> public virtual Matrix Concat(double[,] matrix, MatrixDirection direction) { if (direction == MatrixDirection.Horizontal) { return(new Matrix(MatrixFunctions.ConcatHorizontally(this.InnerMatrix, matrix))); } else { return(new Matrix(MatrixFunctions.ConcatVertically(this.InnerMatrix, matrix))); } }
/// <summary> /// Mirrors matrix entries horizontally / vertically. /// </summary> public virtual Matrix Mirror(MatrixDirection direction) { if (direction == MatrixDirection.Horizontal) { return(new Linears.Matrix(MatrixFunctions.MirrorHorizontally(this.InnerMatrix))); } else { return(new Linears.Matrix(MatrixFunctions.MirrorVertically(this.InnerMatrix))); } }
/// <summary> /// Shrinks matrix by number of rows (from the start / from the end.) /// </summary> public virtual Matrix ShrinkRows(int rowsToShrink, MatrixPosition pos) { int[] rows = null; if (pos == MatrixPosition.Start) { rows = Enumerable.Range(0, rowsToShrink).ToArray(); } else { rows = Enumerable.Range(this.RowCount - rowsToShrink, rowsToShrink).ToArray(); } return(new Matrix(MatrixFunctions.RemoveRows(this.InnerMatrix, rows))); }
/// <summary> /// Shrinks matrix by number of columns (from the start / from the end.) /// </summary> public virtual Matrix ShrinkColumns(int colsToShrink, MatrixPosition pos) { int[] cols = null; if (pos == MatrixPosition.Start) { cols = Enumerable.Range(0, colsToShrink).ToArray(); } else { cols = Enumerable.Range(this.ColumnCount - colsToShrink, colsToShrink).ToArray(); } return(new Matrix(MatrixFunctions.RemoveColumns(this.InnerMatrix, cols))); }
// TODO: Test /// <summary> /// Creates projection matrix for the specified subspace. /// </summary> public static double[,] CreateProjectionMatrix(double[,] subspace) { var subspaceTranspose = MatrixFunctions.Transpose(subspace); double[,] value = MatrixFunctions.Multiply(subspaceTranspose, subspace); value = MatrixFunctions.Invert(value); value = MatrixFunctions.Multiply(value, subspaceTranspose); value = MatrixFunctions.Multiply(subspace, value); return(value); }
/// <summary> /// Reduces matrix to row-echelon (REF/Gauss) or reduced row-echelon (RREF/Gauss-Jordan) form and solves for augmented columns. /// Returns the matrix solution and outputs the full matrix (reduced matrix along with the solution. /// Accepts the number of augmeted columns. If the number specified is null, the default number specified in the matrix is used. /// </summary> /// <returns> /// Returns the matrix solution and outputs the full matrix (reduced matrix along with the solution. /// </returns> /// <remarks> /// The default value for <seealso cref="Elsheimy.Components.Linears.Matrix.AugmentedColumnCount"/> is used. /// </remarks> public virtual Matrix Solve(int?augmentedColCount, out Matrix fullMatrix) { int augmentedCols = augmentedColCount ?? this.AugmentedColumnCount; if (augmentedCols <= 0) { throw new InvalidOperationException(Properties.Resources.Exception_NoAugmentedColumns); } var result = MatrixFunctions.Eliminate(this.InnerMatrix, MatrixReductionForm.ReducedRowEchelonForm, augmentedCols); var state = result.SolutionState; fullMatrix = new Matrix(result.FullMatrix, augmentedCols); if (result.Solution == null) { return(null); } return(new Matrix(result.Solution)); }
/// <summary> /// Returns the state of a solved matrix. /// </summary> public static MatrixSolutionState GetSolutionState(double[,] input, int augmentedCols) { var rowCount = input.GetLength(0); var totalCols = input.GetLength(1); for (int row = 0; row < rowCount; row++) { var sumRow = MatrixFunctions.RowSum(input, row, 0, totalCols - augmentedCols - 1); var sumAug = MatrixFunctions.RowSum(input, row, totalCols - augmentedCols, totalCols - 1); if (sumRow + sumAug == 0) { return(MatrixSolutionState.Infinite); } else if (sumRow == 0) { return(MatrixSolutionState.None); } } return(MatrixSolutionState.Unique); }
/// <summary> /// Returns a value indicates whether matrix is invertible. Internally uses matrix determinant. /// </summary> public virtual bool IsInvertible() { return(MatrixFunctions.IsInvertible(this.InnerMatrix)); }
/// <summary> /// Creates 2-dimensional rotation matrix to the specified angle and direction. /// </summary> public static Matrix Create2DRotationMatrix(double angle, AngleUnit unit, MatrixRotationDirection direction) { return(new Matrix(MatrixFunctions.Create2DRotationMatrix(angle, unit, direction))); }
/// <summary> /// Geenerates random square matrix of n by m dimensions where entries range from 0 to the specified max value. /// </summary> public static Matrix GenerateRandomMatrix(int numRows, int numCols, double maxValue) { return(new Matrix(MatrixFunctions.GenerateRandomMatrix(numRows, numCols, maxValue))); }
/// <summary> /// Creates n-dimensional identity matrix. /// </summary> public static Matrix CreateIdentityMatrix(int length) { return(new Matrix(MatrixFunctions.CreateIdentityMatrix(length))); }
/// <summary> /// Returns the state of a solved matrix. /// Accepts the number of augmeted columns. If the number specified is null, the default number specified in the matrix is used. /// </summary> /// <remarks> /// If <param name="augmentedColCount">augmentedColCount</param> is null, <seealso cref="Elsheimy.Components.Linears.Matrix.AugmentedColumnCount"/> is used. /// </remarks> public virtual MatrixSolutionState GetSolutionState(int?augmentedColCount = null) { int augmentedCols = augmentedColCount ?? this.AugmentedColumnCount; return(MatrixFunctions.GetSolutionState(this.InnerMatrix, augmentedCols)); }
/// <summary> /// Removes specific rows. /// </summary> public virtual Matrix RemoveRows(int[] rows) { return(new Linears.Matrix(MatrixFunctions.RemoveRows(this.InnerMatrix, rows))); }
/// <summary> /// Creates 3-dimensional rotation matrix to the specified angle and direction. /// </summary> public static Matrix Create3DRotationMatrix(double angle, AngleUnit unit, MatrixAxis axis) { return(new Matrix(MatrixFunctions.Create3DRotationMatrix(angle, unit, axis))); }
/// <summary> /// Returns matrix rank. /// Accepts the number of augmeted columns. If the number specified is null, the default number specified in the matrix is used. /// </summary> /// <remarks> /// If <param name="augmentedColCount">augmentedColCount</param> is null, <seealso cref="Elsheimy.Components.Linears.Matrix.AugmentedColumnCount"/> is used. /// </remarks> public virtual int GetRank(int?augmentedColCount = null) { int augmentedCols = augmentedColCount ?? this.AugmentedColumnCount; return(MatrixFunctions.GetRank(this.InnerMatrix, augmentedCols)); }
/// <summary> /// Multiplies/scales matrix by a scalar input. /// </summary> public virtual Matrix Scale(double scalar) { return(new Matrix(MatrixFunctions.Multiply(scalar, this.InnerMatrix))); }
/// <summary> /// Raises matrix to the spcified power. /// </summary> public virtual Matrix Power(int power) { return(new Matrix(MatrixFunctions.Power(this.InnerMatrix, power))); }
/// <summary> /// Multiplies matrix by another. /// </summary> public virtual Matrix Multiply(double[,] matrix) { return(new Matrix(MatrixFunctions.Multiply(this.InnerMatrix, matrix))); }
/// <summary> /// Rounds matrix entries to the nearest integeral value. /// </summary> /// <param name="decimals"></param> /// <returns></returns> public virtual Matrix Round(int decimals) { return(new Matrix(MatrixFunctions.Round(this.InnerMatrix, decimals))); }
/// <summary> /// Removes specific columns. /// </summary> public virtual Matrix RemoveColumns(int[] cols) { return(new Linears.Matrix(MatrixFunctions.RemoveColumns(this.InnerMatrix, cols))); }
/// <summary> /// Creates 2-dimensional reflection matrix over the specified axis. /// </summary> public static Matrix Create2DReflectionMatrix(MatrixAxis axis) { return(new Matrix(MatrixFunctions.Create2DReflectionMatrix(axis))); }
/// <summary> /// Creates 3-dimensional reflection matrix over the specified plane. /// </summary> public static Matrix Create3DReflectionMatrix(Matrix3DReflectionPlane plane) { return(new Matrix(MatrixFunctions.Create3DReflectionMatrix(plane))); }
/// <summary> /// Creates 3-dimensional shearing matrix over the specified axis. /// </summary> public static Matrix Create3DShearingMatrix(double factor, MatrixAxis axis) { return(new Matrix(MatrixFunctions.Create3DShearingMatrix(factor, axis))); }
/// <summary> /// Outputs matrix in a string format. /// </summary> public override string ToString() { return(MatrixFunctions.ToString(InnerMatrix, this.AugmentedColumnCount)); }
/// <summary> /// Reduces matrix to row-echelon (REF/Gauss) or reduced row-echelon (RREF/Gauss-Jordan) form. /// Accepts the number of augmeted columns. If the number specified is null, the default number specified in the matrix is used. /// </summary> /// <remarks> /// If <param name="augmentedColCount">augmentedColCount</param> is null, <seealso cref="Elsheimy.Components.Linears.Matrix.AugmentedColumnCount"/> is used. /// </remarks> public virtual Matrix Reduce(MatrixReductionForm form, int?augmentedColCount = null) { int augmentedCols = augmentedColCount ?? this.AugmentedColumnCount; return(new Matrix(MatrixFunctions.Eliminate(this.InnerMatrix, form, augmentedCols).FullMatrix)); }