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));
}
