GaussJordanElimination.cs

usingSystem;

namespaceAlgorithms.Numeric;

/// <summary>
/// Algorithm used to find the inverse of any matrix that can be inverted.
/// </summary>
publicclassGaussJordanElimination
{
privateintRowCount{get;set;}

/// <summary>
/// Method to find a linear equation system using gaussian elimination.
/// </summary>
/// <param name="matrix">The key matrix to solve via algorithm.</param>
/// <returns>
/// whether the input matrix has a unique solution or not.
/// and solves on the given matrix.
/// </returns>
publicboolSolve(double[,]matrix)
{
RowCount=matrix.GetUpperBound(0)+1;

if(!CanMatrixBeUsed(matrix))
{
thrownewArgumentException("Please use a n*(n+1) matrix with Length > 0.");
}

varpivot=PivotMatrix(refmatrix);
if(!pivot)
{
returnfalse;
}

Elimination(refmatrix);

returnElementaryReduction(refmatrix);
}

/// <summary>
/// To make simple validation of the matrix to be used.
/// </summary>
/// <param name="matrix">Multidimensional array matrix.</param>
/// <returns>
/// True: if algorithm can be use for given matrix;
/// False: Otherwise.
/// </returns>
privateboolCanMatrixBeUsed(double[,]matrix)=>matrix?.Length==RowCount*(RowCount+1)&&RowCount>1;

/// <summary>
/// To prepare given matrix by pivoting rows.
/// </summary>
/// <param name="matrix">Input matrix.</param>
/// <returns>Matrix.</returns>
privateboolPivotMatrix(refdouble[,]matrix)
{
for(varcol=0;col+1<RowCount;col++)
{
if(matrix[col,col]==0)
{
// To find a non-zero coefficient
varrowToSwap=FindNonZeroCoefficient(refmatrix,col);

if(matrix[rowToSwap,col]!=0)
{
vartmp=newdouble[RowCount+1];
for(vari=0;i<RowCount+1;i++)
{
// To make the swap with the element above.
tmp[i]=matrix[rowToSwap,i];
matrix[rowToSwap,i]=matrix[col,i];
matrix[col,i]=tmp[i];
}
}
else
{
// To return that the matrix doesn't have a unique solution.
returnfalse;
}
}
}

returntrue;
}

privateintFindNonZeroCoefficient(refdouble[,]matrix,intcol)
{
varrowToSwap=col+1;

// To find a non-zero coefficient
for(;rowToSwap<RowCount;rowToSwap++)
{
if(matrix[rowToSwap,col]!=0)
{
returnrowToSwap;
}
}

returncol+1;
}

/// <summary>
/// Applies REF.
/// </summary>
/// <param name="matrix">Input matrix.</param>
privatevoidElimination(refdouble[,]matrix)
{
for(varsrcRow=0;srcRow+1<RowCount;srcRow++)
{
for(vardestRow=srcRow+1;destRow<RowCount;destRow++)
{
vardf=matrix[srcRow,srcRow];
varsf=matrix[destRow,srcRow];

for(vari=0;i<RowCount+1;i++)
{
matrix[destRow,i]=matrix[destRow,i]*df-matrix[srcRow,i]*sf;
}
}
}
}

/// <summary>
/// To continue reducing the matrix using RREF.
/// </summary>
/// <param name="matrix">Input matrix.</param>
/// <returns>True if it has a unique solution; false otherwise.</returns>
privateboolElementaryReduction(refdouble[,]matrix)
{
for(varrow=RowCount-1;row>=0;row--)
{
varelement=matrix[row,row];
if(element==0)
{
returnfalse;
}

for(vari=0;i<RowCount+1;i++)
{
matrix[row,i]/=element;
}

for(vardestRow=0;destRow<row;destRow++)
{
matrix[destRow,RowCount]-=matrix[destRow,row]*matrix[row,RowCount];
matrix[destRow,row]=0;
}
}

returntrue;
}
}