private void FillCells(ISquareMatrix matrix, ICell currentCell, ICell nextCell, ref int currentValue)
{
while (true)
{
matrix.Field[currentCell.Row, currentCell.Col] = currentValue;
bool matrixBoundaryReached = this.CheckIfBoundaryReached(matrix.Field, currentCell.Row, currentCell.Col);
if (!matrixBoundaryReached)
{
break;
}
bool steppedOutside = this.CheckIfSteppedOutsideOfMatrix(matrix, currentCell, nextCell);
while (steppedOutside)
{
this.ChangeDirection(nextCell);
steppedOutside = this.CheckIfSteppedOutsideOfMatrix(matrix, currentCell, nextCell);
}
currentCell.Row += nextCell.Row;
currentCell.Col += nextCell.Col;
currentValue++;
}
}
private static void Transpose <T>(ISquareMatrix <T> matrix)
{
for (int row = 0; row < matrix.GetSize() - 1; row++)
{
for (int col = row + 1; col < matrix.GetSize(); col++)
{
Swap(ref matrix.At(row, col), ref matrix.At(col, row));
}
}
}
static void Print(ISquareMatrix <int> matrix)
{
for (int i = 0; i < matrix.Length; ++i)
{
for (int j = 0; j < matrix.Length; ++j)
{
Console.Write(matrix[i, j] + " ");
}
Console.WriteLine();
}
}
internal static double LaplaceExpansion(this ISquareMatrix matrix)
{
double determinant = 0;
for (uint i = 0; i < matrix.Dimension; ++i)
{
determinant += matrix[i, 0] * matrix.GetCofactor(i, 0);
}
// The sigma sign is equal to a for-loop with recursion.
return(determinant);
}
public static void Rotate90DegreesClockwise <T>(ISquareMatrix <T> matrix)
{
Transpose(matrix);
// Mirror left to right
for (int row = 0; row < matrix.GetSize(); row++)
{
for (int col = 0; col < matrix.GetSize() / 2; col++)
{
Swap(ref matrix.At(row, col), ref matrix.At(row, matrix.GetSize() - 1 - col));
}
}
}
public void MatrixHelperExceptionTest()
{
var matrixleft = new SquareMatrix <int>(new int[9] {
3, 4, 0, 0, 4, 0, 0, 0, 15
});
var matrixright = new SymmetricMatrix <int>(new int[3] {
1, 1, 1
});
var newMatrix = new SquareMatrix <int>(3);
ISquareMatrix <int> result = newMatrix;
MatrixHelper.Add <int>((ISquareMatrix <int>)matrixleft, (ISquareMatrix <int>)matrixright, result);
}
public static bool IsNaM(this ISquareMatrix m)
{
int len = m.Length;
for (int i = 0; i < len; i++)
{
if (double.IsNaN(m[i]))
{
return(true);
}
}
return(false);
}
public static void Rotate90DegreesCounterclockwise <T>(ISquareMatrix <T> matrix)
{
Transpose(matrix);
// Mirror top to bottom
for (int col = 0; col < matrix.GetSize(); col++)
{
for (int row = 0; row < matrix.GetSize() / 2; row++)
{
Swap(ref matrix.At(row, col), ref matrix.At(matrix.GetSize() - 1 - row, col));
}
}
}
private void FillMatrixRandomValue(ISquareMatrix obj)
{
var rnd = new Random();
for (var i = 0; i < obj.Rank; i++)
{
for (var j = 0; j < obj.Rank; j++)
{
obj[i, j] = rnd.Next(100);
}
}
Console.WriteLine(obj.ToString());
}
private bool CompareMatrix(ISquareMatrix <int> matrixLeft, ISquareMatrix <int> matrixRight)
{
for (int i = 0; i < 3; ++i)
{
for (int j = 0; j < 3; ++j)
{
if (matrixLeft[i, j] != matrixRight[i, j])
{
return(false);
}
}
}
return(true);
}
//public static TOut GetCore<TOut>(this ISquareMatrix matrix) where TOut : IVector, new()
//{
// if (!matrix.Determinant.IsApproximatelyEqualTo(0))
// throw new InvalidOperationException($"Cannot calculate core of {nameof(matrix)} as its determinant is not 0.");
// var vector = new TOut();
// if (matrix.Dimension != vector.Dimension)
// throw new InvalidOperationException($"Type parameter TOut is not an adequate IVector - type as its dimension does not fit the one of the resulting vector. The dimension must be {matrix.Dimension}.");
// var equations = new List<LinearEquation>((int)matrix.ColumnCount);
// for (uint y = 0; y < matrix.RowCount; ++y)
// {
// var coefficients = new List<double>((int)matrix.ColumnCount);
// for (uint x = 0; x < matrix.ColumnCount; ++x)
// coefficients.Add(matrix[y, x]);
// equations.Add(new LinearEquation(coefficients.ToArray(), 0));
// }
// var equationSystem = new LinearEquationSystem(equations);
// double[] solutions = equationSystem.Solve();
// for (uint i = 0; i < matrix.ColumnCount; ++i)
// vector[i] = solutions[i];
// return vector;
//}
/// <summary>
/// Calculates the determinant of the <see cref="ISquareMatrix" />.
/// </summary>
/// <param name="matrix">The <see cref="ISquareMatrix" /> whose determinant should be calculated.</param>
/// <returns>The determinant of the <see cref="ISquareMatrix" />.</returns>
public static double GetDeterminant(this ISquareMatrix matrix)
{
switch (matrix.Dimension)
{
case 1:
return(matrix[0, 0]);
case 2:
return(matrix[0, 0] * matrix[1, 1] - matrix[0, 1] * matrix[1, 0]);
default:
return(LaplaceExpansion(matrix));
}
}
public static T Mul <T>(this ISquareMatrix lhs, T rhs) where T : IVector
{
int dim = rhs.Dimension;
for (int i = 0; i < dim; i++)
{
double dot = 0;
for (int j = 0; j < dim; j++)
{
dot += lhs[j + i] * rhs[j];
}
rhs[i] = dot;
}
return(rhs);
}
private bool CheckIfSteppedOutsideOfMatrix(ISquareMatrix matrix, ICell currentCell, ICell nextCell)
{
bool steppedOusideRight = currentCell.Row + nextCell.Row >= matrix.Size;
bool steppedOusideLeft = currentCell.Row + nextCell.Row < 0;
bool steppedOusideBottom = currentCell.Col + nextCell.Col >= matrix.Size;
bool steppedOutsideTop = currentCell.Col + nextCell.Col < 0;
bool steppedOuside = steppedOusideRight || steppedOusideLeft || steppedOusideBottom || steppedOutsideTop;
bool isPopulated = false;
if (!steppedOuside)
{
isPopulated = matrix.Field[currentCell.Row + nextCell.Row, currentCell.Col + nextCell.Col] != 0;
}
return(steppedOuside || isPopulated);
}
private ISquareMatrix Adder(ISquareMatrix added, AdderArgument type)
{
if (Rank != added.Rank)
{
throw new ArgumentException();
}
var result = GetZeroMatrix();
for (var i = 0; i < Rank; i++)
{
for (var j = 0; j < Rank; j++)
{
result[i, j] = this[i, j] + added[i, j] * (int)type;
}
}
return(result);
}
/// <summary>
/// Calculates the sub <see cref="IMatrix" /> of the current <see cref="IMatrix" /> by removing the specified column
/// and row.
/// </summary>
/// <param name="matrix">The <see cref="ISquareMatrix" />.</param>
/// <param name="row">The row that should be removed.</param>
/// <param name="column">The column that should be removed.</param>
/// <returns>The calculated sub <see cref="ISquareMatrix" />.</returns>
public static ISquareMatrix GetSubMatrix(this ISquareMatrix matrix, uint row, uint column)
{
ISquareMatrix resultMatrix;
switch (matrix.Dimension)
{
case 2:
resultMatrix = new Matrix1x1();
break;
case 3:
resultMatrix = new Matrix2x2();
break;
case 4:
resultMatrix = new Matrix3x3();
break;
default:
throw new InvalidOperationException("Cannot build sub matrix of " + nameof(matrix) +
" as there is no lower dimension defined for it.");
}
uint y = 0;
for (uint cy = 0; cy < matrix.RowCount; cy++)
{
if (cy != row)
{
uint x = 0;
for (uint cx = 0; cx < matrix.ColumnCount; ++cx)
{
if (cx != column)
{
resultMatrix[y, x] = matrix[cy, cx];
x++;
}
}
y++;
}
}
return(resultMatrix);
}
public void MatrixHelperAddTest()
{
var matrixleft = new SquareMatrix <int>(new int[9] {
3, 4, 0, 0, 4, 0, 0, 0, 15
});
var matrixright = new SymmetricMatrix <int>(new int[6] {
1, 1, 1, 1, 1, 1
});
var newMatrix = new SquareMatrix <int>(3);
ISquareMatrix <int> result = newMatrix;
MatrixHelper.Add <int>((ISquareMatrix <int>)matrixleft, (ISquareMatrix <int>)matrixright, result);
var expected = new SquareMatrix <int>(new int[9] {
4, 5, 1, 1, 5, 1, 1, 1, 16
});
Assert.IsTrue(CompareMatrix((ISquareMatrix <int>)expected, result));
}
//public static T GetInverse<T>(this ISquareMatrix matrix) where T : ISquareMatrix, new()
//{
// if (matrix.Determinant.IsApproximatelyEqualTo(0))
// throw new InvalidOperationException("The specified matrix does not have an inverse.");
// return GaussJordan(matrix, GetIdentity())
//}
/// <summary>
/// Determines whether the <see cref="ISquareMatrix" /> is a diagonal <see cref="ISquareMatrix" />, or not.
/// </summary>
/// <param name="matrix">The <see cref="ISquareMatrix" />.</param>
/// <returns>
/// <c>true</c>, if the <see cref="ISquareMatrix" /> is a diagonal <see cref="ISquareMatrix" />, otherwise
/// <c>false</c>.
/// </returns>
public static bool GetIsDiagonal(this ISquareMatrix matrix)
{
if (matrix.Dimension == 1)
{
return(false);
}
for (uint y = 0; y < matrix.RowCount; ++y)
{
for (uint x = 0; x < matrix.ColumnCount; ++x)
{
if (y == x && FloatingNumber.AreApproximatelyEqual(matrix[y, x], 0) ||
y != x && !FloatingNumber.AreApproximatelyEqual(matrix[y, x], 0))
{
return(false);
}
}
}
return(true);
}
public ISquareMatrix Multiply(ISquareMatrix factor)
{
if (Rank != factor.Rank)
{
throw new ArgumentException();
}
var result = GetZeroMatrix();
for (var i = 0; i < Rank; i++)
{
for (var j = 0; j < Rank; j++)
{
for (var k = 0; k < Rank; k++)
{
result[i, j] = this[i, k] * factor[k, j];
}
}
}
return(result);
}
/// <summary>
/// Determines whether the <see cref="ISquareMatrix" /> is a triangle <see cref="ISquareMatrix" />, or not.
/// </summary>
/// <param name="matrix">The <see cref="ISquareMatrix" />.</param>
/// <returns>
/// <c>true</c>, if the <see cref="ISquareMatrix" /> is a triangle <see cref="ISquareMatrix" />, otherwise
/// <c>false</c>.
/// </returns>
public static bool GetIsTriangle(this ISquareMatrix matrix)
{
if (matrix.Dimension == 1)
{
return(false);
}
var upperTriangle = new List <double>();
var lowerTriangle = new List <double>();
for (uint y = 0; y < matrix.RowCount; ++y)
{
var isRightSide = false;
for (uint x = 0; x < matrix.ColumnCount; ++x)
{
if (y == x)
{
isRightSide = true;
continue;
}
if (isRightSide)
{
upperTriangle.Add(matrix[y, x]);
}
else
{
lowerTriangle.Add(matrix[y, x]);
}
}
}
if (upperTriangle.All(val => val.IsApproximatelyEqualTo(0)) ||
lowerTriangle.All(val => val.IsApproximatelyEqualTo(0)))
{
return(true);
}
return(false);
}
public static void Add <T>(ISquareMatrix <T> matrixleft, ISquareMatrix <T> matrixright, ISquareMatrix <T> result)
{
if (matrixleft == null || matrixright == null || result == null || matrixleft.Length != matrixright.Length ||
matrixleft.Length != result.Length)
{
throw new ArgumentException();
}
for (int i = 0; i < matrixleft.Length; ++i)
{
for (int j = 0; j < matrixleft.Length; ++j)
{
try
{
result[i, j] = (dynamic)matrixleft[i, j] + matrixright[i, j];
}
catch (Exception e)
{
throw new ArgumentException("Invalid operation");
}
}
}
}
public ISquareMatrix Add(ISquareMatrix matrix)
{
return(base.Add(matrix).AsSquare());
}
public ISquareMatrix Multiply(ISquareMatrix matrix)
{
return(base.Multiply(matrix).AsSquare());
}
/// <summary>
/// Calculates the cofactor of an element at the specified position in the <see cref="ISquareMatrix" />.
/// </summary>
/// <param name="matrix">The <see cref="ISquareMatrix" />.</param>
/// <param name="row">The row of the element.</param>
/// <param name="column">The column of the element.</param>
/// <returns>The cofactor of the element in this <see cref="ISquareMatrix" />.</returns>
public static double GetCofactor(this ISquareMatrix matrix, uint row, uint column)
{
return(Math.Pow(-1, row + column) * matrix.GetSubMatrix(row, column).GetDeterminant());
}
public ISquareMatrix Sub(ISquareMatrix subtrahend)
{
return(Adder(subtrahend, AdderArgument.Sub));
}
public ISquareMatrix Add(ISquareMatrix added)
{
return(Adder(added, AdderArgument.Add));
}
public OSquareMatrix(ISquareMatrix matrix)
{
_matrix = matrix;
}
public ISquareMatrix Subtract(ISquareMatrix matrix)
{
return(base.Subtract(matrix).AsSquare());
}
public SquareMatrixFiller(ISquareMatrix matrix, ICell currentCell, ICell nextCell)
{
this.Matrix = matrix;
this.CurrentCell = currentCell;
this.NextCell = nextCell;
}
